Merge pull request #1274 from Lamothe/fix-some-warnings

martindevans · web-flow · commit 13eada9c76ed · 2025-10-19T15:27:04.000+01:00
Fix some warnings.
diff --git a/LLama.Examples/Examples/QuantizeModel.cs b/LLama.Examples/Examples/QuantizeModel.cs
@@ -20,6 +20,8 @@ public static async Task Run()
             {
                 Console.WriteLine("Quantization failed!");
             }
+
+            await Task.CompletedTask;
         }
     }
 }
diff --git a/LLama/Batched/Conversation.cs b/LLama/Batched/Conversation.cs
@@ -410,7 +410,7 @@ public void Remove(LLamaPos start, LLamaPos end)
         }
 
         /// <summary>
-        /// Removes <see cref="count"/> tokens starting from <see cref="start"/>
+        /// Removes <paramref name="count"/> tokens starting from <paramref name="start"/>
         /// </summary>
         /// <param name="start">Start position (inclusive)</param>
         /// <param name="count">Number of tokens</param>
diff --git a/LLama/Common/FixedSizeQueue.cs b/LLama/Common/FixedSizeQueue.cs
@@ -14,7 +14,6 @@ public class FixedSizeQueue<T>
         private readonly T[] _buffer;
         private int _start;
         private int _count;
-        private T[]? _window;
 
         // Minimum capacity for the temporary buffer used to expose a contiguous view.
         private const int MinimumWindowSize = 4;
diff --git a/LLama/LLamaExecutorBase.cs b/LLama/LLamaExecutorBase.cs
@@ -317,7 +317,7 @@ public virtual async IAsyncEnumerable<string> InferAsync(string? text, IInferenc
                 NeedToSaveSession = !string.IsNullOrEmpty(_pathSession) && _n_matching_session_tokens < _embed_inps.Count
             };
 
-            AntipromptProcessor.SetAntiprompts(inferenceParams.AntiPrompts ?? Array.Empty<string>());
+            AntipromptProcessor.SetAntiprompts(inferenceParams.AntiPrompts ?? []);
 
             await PreprocessInputs(text, args);
 
diff --git a/LLama/LLamaInstructExecutor.cs b/LLama/LLamaInstructExecutor.cs
@@ -99,6 +99,7 @@ public override async Task SaveState(string filename)
                 await JsonSerializer.SerializeAsync(fs, state);
             }
         }
+
         /// <inheritdoc />
         public override async Task LoadState(string filename)
         {
@@ -154,19 +155,19 @@ protected override Task PreprocessInputs(string? text, InferStateArgs args)
         }
 
         /// <inheritdoc />
-        protected override async Task<(bool, IReadOnlyList<string>)> PostProcess(IInferenceParams inferenceParams, InferStateArgs args)
+        protected override Task<(bool, IReadOnlyList<string>)> PostProcess(IInferenceParams inferenceParams, InferStateArgs args)
         {
             if (_embed_inps.Count <= _consumedTokensCount)
             {
                 if (!string.IsNullOrEmpty(args.LastOutput) && AntipromptProcessor.Add(args.LastOutput))
                 {
                     args.WaitForInput = true;
-                    return (true, Array.Empty<string>());
+                    return Task.FromResult<(bool, IReadOnlyList<string>)>((true, []));
                 }
 
                 if (_pastTokensCount > 0 && args.WaitForInput)
                 {
-                    return (true, new[] { "\n> " });
+                    return Task.FromResult<(bool, IReadOnlyList<string>)>((true, [ "\n> " ]));
                 }
             }
 
@@ -180,7 +181,7 @@ protected override Task PreprocessInputs(string? text, InferStateArgs args)
                 args.RemainedTokens = inferenceParams.MaxTokens;
                 args.WaitForInput = true;
             }
-            return (false, Array.Empty<string>());
+            return Task.FromResult<(bool, IReadOnlyList<string>)>((false, []));
         }
 
         /// <inheritdoc />
@@ -205,7 +206,9 @@ protected override async Task InferInternal(IInferenceParams inferenceParams, In
                 _pastTokensCount = pastTokensCount;
 
                 if (result != DecodeResult.Ok)
+                {
                     throw new LLamaDecodeError(result);
+                }
 
                 if (_embeds.Count > 0 && !string.IsNullOrEmpty(_pathSession))
                 {
@@ -250,6 +253,7 @@ protected override async Task InferInternal(IInferenceParams inferenceParams, In
 
             return;
         }
+        
         /// <summary>
         /// The descriptor of the state of the instruct executor.
         /// </summary>
diff --git a/LLama/LLamaInteractExecutor.cs b/LLama/LLamaInteractExecutor.cs
@@ -21,7 +21,7 @@ namespace LLama
     public class InteractiveExecutor : StatefulExecutorBase
     {
         private bool _is_prompt_run = true;
-        
+
         // LLava
         private int _EmbedImagePosition = -1;
         private List<SafeLlavaImageEmbedHandle> _imageEmbedHandles = new List<SafeLlavaImageEmbedHandle>();
@@ -36,7 +36,7 @@ public InteractiveExecutor(LLamaContext context, ILogger? logger = null)
             : base(context, logger)
         {
         }
-        
+
         /// <summary>
         /// 
         /// </summary>
@@ -46,7 +46,7 @@ public InteractiveExecutor(LLamaContext context, ILogger? logger = null)
         public InteractiveExecutor(LLamaContext context, LLavaWeights clipModel, ILogger? logger = null)
             : base(context, clipModel, logger)
         {
-        }        
+        }
 
         /// <inheritdoc />
         public override ExecutorBaseState GetStateData()
@@ -67,6 +67,7 @@ public override ExecutorBaseState GetStateData()
             };
             return state;
         }
+
         /// <inheritdoc />
         public override Task LoadState(ExecutorBaseState data)
         {
@@ -88,23 +89,23 @@ public override Task LoadState(ExecutorBaseState data)
 
             return Task.CompletedTask;
         }
+
         /// <inheritdoc />
         public override async Task SaveState(string filename)
         {
             var state = (InteractiveExecutorState)GetStateData();
-            using(var fs = new FileStream(filename, FileMode.Create, FileAccess.Write))
+            using (var fs = new FileStream(filename, FileMode.Create, FileAccess.Write))
             {
                 await JsonSerializer.SerializeAsync(fs, state);
             }
         }
+
         /// <inheritdoc />
         public override async Task LoadState(string filename)
         {
-            using (var fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
-            {
-                var state = await JsonSerializer.DeserializeAsync<InteractiveExecutorState>(fs);
-                await LoadState(state!);
-            }
+            using var fs = new FileStream(filename, FileMode.Open, FileAccess.Read);
+            var state = await JsonSerializer.DeserializeAsync<InteractiveExecutorState>(fs);
+            await LoadState(state!);
         }
 
         /// <summary>
@@ -122,7 +123,11 @@ protected override Task PreprocessInputs(string? text, InferStateArgs args)
             if (_is_prompt_run)
             {
                 // When running the first input (prompt) in interactive mode, we should specially process it.
-                if (text == null) throw new ArgumentException("Prompt cannot be null to trigger continuation if a prompt has not been provided previously.");
+                if (text == null)
+                {
+                    throw new ArgumentException("Prompt cannot be null to trigger continuation if a prompt has not been provided previously.");
+                }
+
                 if (!IsMultiModal)
                 {
                     _embed_inps = Context.Tokenize(text, true, true).ToList();
@@ -159,8 +164,8 @@ protected override Task PreprocessInputs(string? text, InferStateArgs args)
         }
 
         /// <inheritdoc />
-        private Task PreprocessLlava(string text, InferStateArgs args, bool addBos = true )
-        {   
+        private Task PreprocessLlava(string text, InferStateArgs args, bool addBos = true)
+        {
             // If the prompt contains the tag <image> extract this.
             _imageInPrompt = text.Contains("<image>");
             if (_imageInPrompt && IsMultiModal)
@@ -191,7 +196,7 @@ private Task PreprocessLlava(string text, InferStateArgs args, bool addBos = tru
                 {
                     var line_inp = Context.Tokenize(text, false, true);
                     _embed_inps.AddRange(line_inp);
-                    args.RemainedTokens -= line_inp.Length;                    
+                    args.RemainedTokens -= line_inp.Length;
                 }
             }
             return Task.CompletedTask;
@@ -203,20 +208,24 @@ private Task PreprocessLlava(string text, InferStateArgs args, bool addBos = tru
         /// <param name="inferenceParams"></param>
         /// <param name="args"></param>
         /// <returns></returns>
-        protected override async Task<(bool, IReadOnlyList<string>)> PostProcess(IInferenceParams inferenceParams, InferStateArgs args)
+        protected override Task<(bool, IReadOnlyList<string>)> PostProcess(IInferenceParams inferenceParams, InferStateArgs args)
         {
             if (_embed_inps.Count <= _consumedTokensCount)
             {
                 if (!string.IsNullOrEmpty(args.LastOutput) && AntipromptProcessor.Add(args.LastOutput))
+                {
                     args.WaitForInput = true;
+                }
 
                 if (_pastTokensCount > 0 && args.WaitForInput)
-                    return (true, Array.Empty<string>());
+                {
+                    return Task.FromResult((true, (IReadOnlyList<string>)[]));
+                }
             }
 
             if (_embeds.Count > 0 && _embeds.Last().IsEndOfGeneration(Context.Vocab))
             {
-                return (true, Array.Empty<string>());
+                return Task.FromResult((true, (IReadOnlyList<string>)[]));
             }
 
             if (args.RemainedTokens <= 0 && inferenceParams.MaxTokens != -1)
@@ -225,7 +234,7 @@ private Task PreprocessLlava(string text, InferStateArgs args, bool addBos = tru
                 args.WaitForInput = true;
             }
 
-            return (false, Array.Empty<string>());
+            return Task.FromResult((true, (IReadOnlyList<string>)[]));
         }
 
         /// <inheritdoc />
@@ -258,18 +267,18 @@ protected override async Task InferInternal(IInferenceParams inferenceParams, In
                 // Changes to support Multi-Modal LLMs.
                 //
                 (DecodeResult, int, int) header, end, result;
-                if (IsMultiModal &&  _EmbedImagePosition > 0)
+                if (IsMultiModal && _EmbedImagePosition > 0)
                 {
                     // Tokens previous to the images
                     header = await Context.DecodeAsync(_embeds.GetRange(0, _EmbedImagePosition), LLamaSeqId.Zero, batch, _pastTokensCount);
                     _pastTokensCount = header.Item3;
 
                     if (header.Item1 != DecodeResult.Ok) throw new LLamaDecodeError(header.Item1);
-                   
+
                     // Images
-                    foreach( var image in _imageEmbedHandles )
+                    foreach (var image in _imageEmbedHandles)
                         ClipModel!.EvalImageEmbed(Context, image, ref _pastTokensCount);
-                        
+
                     // Post-image Tokens
                     end = await Context.DecodeAsync(_embeds.GetRange(_EmbedImagePosition, _embeds.Count - _EmbedImagePosition), LLamaSeqId.Zero, batch, _pastTokensCount);
                     _pastTokensCount = end.Item3;
@@ -285,7 +294,7 @@ protected override async Task InferInternal(IInferenceParams inferenceParams, In
 
                     if (result.Item1 != DecodeResult.Ok) throw new LLamaDecodeError(result.Item1);
                 }
-                
+
 
                 if (_embeds.Count > 0 && !string.IsNullOrEmpty(_pathSession))
                 {
diff --git a/LLama/Native/SafeLlamaModelHandle.cs b/LLama/Native/SafeLlamaModelHandle.cs
@@ -436,6 +436,7 @@ private static int llama_model_meta_val_str(SafeLlamaModelHandle model, string k
         /// </summary>
         /// <param name="model"></param>
         /// <returns></returns>
+        [DllImport(NativeApi.libraryName, CallingConvention = CallingConvention.Cdecl)]
         private static extern uint llama_model_n_cls_out(SafeLlamaModelHandle model);
 
         /// <summary>
@@ -444,6 +445,7 @@ private static int llama_model_meta_val_str(SafeLlamaModelHandle model, string k
         /// <param name="model"></param>
         /// <param name="i"></param>
         /// <returns></returns>
+        [DllImport(NativeApi.libraryName, CallingConvention = CallingConvention.Cdecl)]
         private static extern string? llama_model_cls_label(SafeLlamaModelHandle model, uint i);
         #endregion
 

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,8 @@ public static async Task Run()`
`20`	`20`	`{`
`21`	`21`	`Console.WriteLine("Quantization failed!");`
`22`	`22`	`}`
	`23`	`+`
	`24`	`+ await Task.CompletedTask;`
`23`	`25`	`}`
`24`	`26`	`}`
`25`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -410,7 +410,7 @@ public void Remove(LLamaPos start, LLamaPos end)`
`410`	`410`	`}`
`411`	`411`
`412`	`412`	`/// <summary>`
`413`		`- /// Removes <see cref="count"/> tokens starting from <see cref="start"/>`
	`413`	`+ /// Removes <paramref name="count"/> tokens starting from <paramref name="start"/>`
`414`	`414`	`/// </summary>`
`415`	`415`	`/// <param name="start">Start position (inclusive)</param>`
`416`	`416`	`/// <param name="count">Number of tokens</param>`
Original file line number	Diff line number	Diff line change
`@@ -99,6 +99,7 @@ public override async Task SaveState(string filename)`
`99`	`99`	`await JsonSerializer.SerializeAsync(fs, state);`
`100`	`100`	`}`
`101`	`101`	`}`
	`102`	`+`
`102`	`103`	`/// <inheritdoc />`
`103`	`104`	`public override async Task LoadState(string filename)`
`104`	`105`	`{`
`@@ -154,19 +155,19 @@ protected override Task PreprocessInputs(string? text, InferStateArgs args)`
`154`	`155`	`}`
`155`	`156`
`156`	`157`	`/// <inheritdoc />`
`157`		`- protected override async Task<(bool, IReadOnlyList<string>)> PostProcess(IInferenceParams inferenceParams, InferStateArgs args)`
	`158`	`+ protected override Task<(bool, IReadOnlyList<string>)> PostProcess(IInferenceParams inferenceParams, InferStateArgs args)`
`158`	`159`	`{`
`159`	`160`	`if (_embed_inps.Count <= _consumedTokensCount)`
`160`	`161`	`{`
`161`	`162`	`if (!string.IsNullOrEmpty(args.LastOutput) && AntipromptProcessor.Add(args.LastOutput))`
`162`	`163`	`{`
`163`	`164`	`args.WaitForInput = true;`
`164`		`- return (true, Array.Empty<string>());`
	`165`	`+ return Task.FromResult<(bool, IReadOnlyList<string>)>((true, []));`
`165`	`166`	`}`
`166`	`167`
`167`	`168`	`if (_pastTokensCount > 0 && args.WaitForInput)`
`168`	`169`	`{`
`169`		`- return (true, new[] { "\n> " });`
	`170`	`+ return Task.FromResult<(bool, IReadOnlyList<string>)>((true, [ "\n> " ]));`
`170`	`171`	`}`
`171`	`172`	`}`
`172`	`173`
`@@ -180,7 +181,7 @@ protected override Task PreprocessInputs(string? text, InferStateArgs args)`
`180`	`181`	`args.RemainedTokens = inferenceParams.MaxTokens;`
`181`	`182`	`args.WaitForInput = true;`
`182`	`183`	`}`
`183`		`- return (false, Array.Empty<string>());`
	`184`	`+ return Task.FromResult<(bool, IReadOnlyList<string>)>((false, []));`
`184`	`185`	`}`
`185`	`186`
`186`	`187`	`/// <inheritdoc />`
`@@ -205,7 +206,9 @@ protected override async Task InferInternal(IInferenceParams inferenceParams, In`
`205`	`206`	`_pastTokensCount = pastTokensCount;`
`206`	`207`
`207`	`208`	`if (result != DecodeResult.Ok)`
	`209`	`+ {`
`208`	`210`	`throw new LLamaDecodeError(result);`
	`211`	`+ }`
`209`	`212`
`210`	`213`	`if (_embeds.Count > 0 && !string.IsNullOrEmpty(_pathSession))`
`211`	`214`	`{`
`@@ -250,6 +253,7 @@ protected override async Task InferInternal(IInferenceParams inferenceParams, In`
`250`	`253`
`251`	`254`	`return;`
`252`	`255`	`}`
	`256`	`+`
`253`	`257`	`/// <summary>`
`254`	`258`	`/// The descriptor of the state of the instruct executor.`
`255`	`259`	`/// </summary>`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ namespace LLama`
`21`	`21`	`public class InteractiveExecutor : StatefulExecutorBase`
`22`	`22`	`{`
`23`	`23`	`private bool _is_prompt_run = true;`
`24`		`-`
	`24`	`+`
`25`	`25`	`// LLava`
`26`	`26`	`private int _EmbedImagePosition = -1;`
`27`	`27`	`private List<SafeLlavaImageEmbedHandle> _imageEmbedHandles = new List<SafeLlavaImageEmbedHandle>();`
`@@ -36,7 +36,7 @@ public InteractiveExecutor(LLamaContext context, ILogger? logger = null)`
`36`	`36`	`: base(context, logger)`
`37`	`37`	`{`
`38`	`38`	`}`
`39`		`-`
	`39`	`+`
`40`	`40`	`/// <summary>`
`41`	`41`	`///`
`42`	`42`	`/// </summary>`
`@@ -46,7 +46,7 @@ public InteractiveExecutor(LLamaContext context, ILogger? logger = null)`
`46`	`46`	`public InteractiveExecutor(LLamaContext context, LLavaWeights clipModel, ILogger? logger = null)`
`47`	`47`	`: base(context, clipModel, logger)`
`48`	`48`	`{`
`49`		`- }`
	`49`	`+ }`
`50`	`50`
`51`	`51`	`/// <inheritdoc />`
`52`	`52`	`public override ExecutorBaseState GetStateData()`
`@@ -67,6 +67,7 @@ public override ExecutorBaseState GetStateData()`
`67`	`67`	`};`
`68`	`68`	`return state;`
`69`	`69`	`}`
	`70`	`+`
`70`	`71`	`/// <inheritdoc />`
`71`	`72`	`public override Task LoadState(ExecutorBaseState data)`
`72`	`73`	`{`
`@@ -88,23 +89,23 @@ public override Task LoadState(ExecutorBaseState data)`
`88`	`89`
`89`	`90`	`return Task.CompletedTask;`
`90`	`91`	`}`
	`92`	`+`
`91`	`93`	`/// <inheritdoc />`
`92`	`94`	`public override async Task SaveState(string filename)`
`93`	`95`	`{`
`94`	`96`	`var state = (InteractiveExecutorState)GetStateData();`
`95`		`- using(var fs = new FileStream(filename, FileMode.Create, FileAccess.Write))`
	`97`	`+ using (var fs = new FileStream(filename, FileMode.Create, FileAccess.Write))`
`96`	`98`	`{`
`97`	`99`	`await JsonSerializer.SerializeAsync(fs, state);`
`98`	`100`	`}`
`99`	`101`	`}`
	`102`	`+`
`100`	`103`	`/// <inheritdoc />`
`101`	`104`	`public override async Task LoadState(string filename)`
`102`	`105`	`{`
`103`		`- using (var fs = new FileStream(filename, FileMode.Open, FileAccess.Read))`
`104`		`- {`
`105`		`- var state = await JsonSerializer.DeserializeAsync<InteractiveExecutorState>(fs);`
`106`		`- await LoadState(state!);`
`107`		`- }`
	`106`	`+ using var fs = new FileStream(filename, FileMode.Open, FileAccess.Read);`
	`107`	`+ var state = await JsonSerializer.DeserializeAsync<InteractiveExecutorState>(fs);`
	`108`	`+ await LoadState(state!);`
`108`	`109`	`}`
`109`	`110`
`110`	`111`	`/// <summary>`
`@@ -122,7 +123,11 @@ protected override Task PreprocessInputs(string? text, InferStateArgs args)`
`122`	`123`	`if (_is_prompt_run)`
`123`	`124`	`{`
`124`	`125`	`// When running the first input (prompt) in interactive mode, we should specially process it.`
`125`		`- if (text == null) throw new ArgumentException("Prompt cannot be null to trigger continuation if a prompt has not been provided previously.");`
	`126`	`+ if (text == null)`
	`127`	`+ {`
	`128`	`+ throw new ArgumentException("Prompt cannot be null to trigger continuation if a prompt has not been provided previously.");`
	`129`	`+ }`
	`130`	`+`
`126`	`131`	`if (!IsMultiModal)`
`127`	`132`	`{`
`128`	`133`	`_embed_inps = Context.Tokenize(text, true, true).ToList();`
`@@ -159,8 +164,8 @@ protected override Task PreprocessInputs(string? text, InferStateArgs args)`
`159`	`164`	`}`
`160`	`165`
`161`	`166`	`/// <inheritdoc />`
`162`		`- private Task PreprocessLlava(string text, InferStateArgs args, bool addBos = true )`
`163`		`- {`
	`167`	`+ private Task PreprocessLlava(string text, InferStateArgs args, bool addBos = true)`
	`168`	`+ {`
`164`	`169`	`// If the prompt contains the tag <image> extract this.`
`165`	`170`	`_imageInPrompt = text.Contains("<image>");`
`166`	`171`	`if (_imageInPrompt && IsMultiModal)`
`@@ -191,7 +196,7 @@ private Task PreprocessLlava(string text, InferStateArgs args, bool addBos = tru`
`191`	`196`	`{`
`192`	`197`	`var line_inp = Context.Tokenize(text, false, true);`
`193`	`198`	`_embed_inps.AddRange(line_inp);`
`194`		`- args.RemainedTokens -= line_inp.Length;`
	`199`	`+ args.RemainedTokens -= line_inp.Length;`
`195`	`200`	`}`
`196`	`201`	`}`
`197`	`202`	`return Task.CompletedTask;`
`@@ -203,20 +208,24 @@ private Task PreprocessLlava(string text, InferStateArgs args, bool addBos = tru`
`203`	`208`	`/// <param name="inferenceParams"></param>`
`204`	`209`	`/// <param name="args"></param>`
`205`	`210`	`/// <returns></returns>`
`206`		`- protected override async Task<(bool, IReadOnlyList<string>)> PostProcess(IInferenceParams inferenceParams, InferStateArgs args)`
	`211`	`+ protected override Task<(bool, IReadOnlyList<string>)> PostProcess(IInferenceParams inferenceParams, InferStateArgs args)`
`207`	`212`	`{`
`208`	`213`	`if (_embed_inps.Count <= _consumedTokensCount)`
`209`	`214`	`{`
`210`	`215`	`if (!string.IsNullOrEmpty(args.LastOutput) && AntipromptProcessor.Add(args.LastOutput))`
	`216`	`+ {`
`211`	`217`	`args.WaitForInput = true;`
	`218`	`+ }`
`212`	`219`
`213`	`220`	`if (_pastTokensCount > 0 && args.WaitForInput)`
`214`		`- return (true, Array.Empty<string>());`
	`221`	`+ {`
	`222`	`+ return Task.FromResult((true, (IReadOnlyList<string>)[]));`
	`223`	`+ }`
`215`	`224`	`}`
`216`	`225`
`217`	`226`	`if (_embeds.Count > 0 && _embeds.Last().IsEndOfGeneration(Context.Vocab))`
`218`	`227`	`{`
`219`		`- return (true, Array.Empty<string>());`
	`228`	`+ return Task.FromResult((true, (IReadOnlyList<string>)[]));`
`220`	`229`	`}`
`221`	`230`
`222`	`231`	`if (args.RemainedTokens <= 0 && inferenceParams.MaxTokens != -1)`
`@@ -225,7 +234,7 @@ private Task PreprocessLlava(string text, InferStateArgs args, bool addBos = tru`
`225`	`234`	`args.WaitForInput = true;`
`226`	`235`	`}`
`227`	`236`
`228`		`- return (false, Array.Empty<string>());`
	`237`	`+ return Task.FromResult((true, (IReadOnlyList<string>)[]));`
`229`	`238`	`}`
`230`	`239`
`231`	`240`	`/// <inheritdoc />`
`@@ -258,18 +267,18 @@ protected override async Task InferInternal(IInferenceParams inferenceParams, In`
`258`	`267`	`// Changes to support Multi-Modal LLMs.`
`259`	`268`	`//`
`260`	`269`	`(DecodeResult, int, int) header, end, result;`
`261`		`- if (IsMultiModal && _EmbedImagePosition > 0)`
	`270`	`+ if (IsMultiModal && _EmbedImagePosition > 0)`
`262`	`271`	`{`
`263`	`272`	`// Tokens previous to the images`
`264`	`273`	`header = await Context.DecodeAsync(_embeds.GetRange(0, _EmbedImagePosition), LLamaSeqId.Zero, batch, _pastTokensCount);`
`265`	`274`	`_pastTokensCount = header.Item3;`
`266`	`275`
`267`	`276`	`if (header.Item1 != DecodeResult.Ok) throw new LLamaDecodeError(header.Item1);`
`268`		`-`
	`277`	`+`
`269`	`278`	`// Images`
`270`		`- foreach( var image in _imageEmbedHandles )`
	`279`	`+ foreach (var image in _imageEmbedHandles)`
`271`	`280`	`ClipModel!.EvalImageEmbed(Context, image, ref _pastTokensCount);`
`272`		`-`
	`281`	`+`
`273`	`282`	`// Post-image Tokens`
`274`	`283`	`end = await Context.DecodeAsync(_embeds.GetRange(_EmbedImagePosition, _embeds.Count - _EmbedImagePosition), LLamaSeqId.Zero, batch, _pastTokensCount);`
`275`	`284`	`_pastTokensCount = end.Item3;`
`@@ -285,7 +294,7 @@ protected override async Task InferInternal(IInferenceParams inferenceParams, In`
`285`	`294`
`286`	`295`	`if (result.Item1 != DecodeResult.Ok) throw new LLamaDecodeError(result.Item1);`
`287`	`296`	`}`
`288`		`-`
	`297`	`+`
`289`	`298`
`290`	`299`	`if (_embeds.Count > 0 && !string.IsNullOrEmpty(_pathSession))`
`291`	`300`	`{`