.NET: [Feature]: tools support NativeAot

[williamlzw]

Description

dotnet:
tools support NativeAot

Code Sample

var skillsProvider = new AgentSkillsProvider(
    Path.GetFullPath(Config.SKILLS_DIR),
    SubprocessScriptRunner.RunAsync);
var config = new OllamaApiClient.Configuration
{
    Uri = new Uri(Config.OLLAMA_API_URL),
    Model = Config.OLLAMA_MODEL,
    JsonSerializerContext = OllamaJsonContext.Default
};
// 创建主客户端
OllamaApiClient client = new OllamaApiClient(config);

// 创建主Agent
return client.AsAIAgent(options: new ChatClientAgentOptions
{
    Name = "LeadAgent",
    ChatOptions = new ChatOptions
    {
        Instructions = Config.AGENT_INSTRUCTIONS,
        Reasoning = new() { Effort = ReasoningEffort.High },
        Tools = NativeAotTools.GetAllTools()//not support nativeaot
    },
    AIContextProviders = [skillsProvider]
});

internal static class NativeAotTools
{

    // ==================== 3. ReadFile 工具 ====================
    public static readonly AIFunctionDeclaration ReadFileDecl = AIFunctionFactory.CreateDeclaration(
        name: "ReadFile",
        description: "【沙箱文件读取】仅可读取Agent沙箱workspace目录内的文件，路径必须以/开头，禁止传入本地绝对路径",
        jsonSchema: JsonDocument.Parse("""
        {
            "type": "object",
            "additionalProperties": false,
            "properties": {
                "file_path": { "type": "string", "description": "文件路径，必须以/开头" },
                "encoding": { "type": ["string", "null"], "description": "编码，默认utf-8" },
                "create_if_missing": { "type": "boolean", "default": false, "description": "文件不存在时是否创建空文件" }
            },
            "required": ["file_path"]
        }
        """).RootElement);
    public static ValueTask<object?> ExecReadFile(AIFunctionArguments args, CancellationToken ct)
    {
        string path = args["file_path"]!.ToString();
        string? encoding = args.TryGetValue("encoding", out var e) ? e.ToString() : null;
        bool create = args.TryGetValue("create_if_missing", out var c) && bool.Parse(c.ToString());
        return ValueTask.FromResult<object?>(FileTools.ReadFile(path, encoding, create));
    }
    /// <summary>
    /// 注册所有 NativeAOT 兼容工具（Declaration + Executor）
    /// </summary>
    public static List<AITool> GetAllTools()
    {
        var ret = new List<AITool>();
        ret.Add(ReadFileDecl);
        return ret;
    }
}

Language/SDK

.NET

[chetantoshniwal]

@SergeyMenshykh can you evaluate the request.

[semenshi]

@williamlzw, what error are you seeing under NativeAOT?

In the meantime, here's an approach that should work - drop CreateDeclaration and use AIFunctionFactory.Create() with a typed model class and a source-generated JsonSerializerContext.

---

Define a typed args class - the framework generates the JSON schema from it automatically:

internal sealed class ReadFileArgs
{
    [Description("File path, must start with /")]
    [JsonPropertyName("file_path")]
    public required string FilePath { get; init; }

    [Description("Encoding, defaults to utf-8")]
    [JsonPropertyName("encoding")]
    public string? Encoding { get; init; }

    [Description("Create an empty file if it doesn't exist")]
    [JsonPropertyName("create_if_missing")]
    public bool CreateIfMissing { get; init; }
}

---

Register it for NativeAOT via JsonSerializerContext (same pattern as AgentJsonUtilities in this repo):

[JsonSourceGenerationOptions(
    JsonSerializerDefaults.Web,
    UseStringEnumConverter = true,
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    NumberHandling = JsonNumberHandling.AllowReadingFromString)]
[JsonSerializable(typeof(ReadFileArgs))]
internal sealed partial class NativeAotJsonContext : JsonSerializerContext;

---

Build JsonSerializerOptions from your context:

internal static class ToolJsonUtilities
{
    public static JsonSerializerOptions DefaultOptions { get; } = CreateDefaultOptions();

    private static JsonSerializerOptions CreateDefaultOptions()
    {
        var options = new JsonSerializerOptions(NativeAotJsonContext.Default.Options)
        {
            Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
        };
        options.TypeInfoResolverChain.Clear();
        options.TypeInfoResolverChain.Add(NativeAotJsonContext.Default);
        options.MakeReadOnly();
        return options;
    }
}

---

Refactor NativeAotTools - use AIFunctionFactory.Create() and pass SerializerOptions:

internal static class NativeAotTools
{
    [Description("Read a file from the agent sandbox workspace directory. Path must start with /.")]
    private static string ExecReadFile(ReadFileArgs args)
    {
        return FileTools.ReadFile(args.FilePath, args.Encoding, args.CreateIfMissing);
    }

    public static List<AITool> GetAllTools()
    {
        var serializerOptions = ToolJsonUtilities.DefaultOptions;
        return
        [
            AIFunctionFactory.Create(ExecReadFile, new AIFunctionFactoryOptions
            {
                Name = "ReadFile",
                SerializerOptions = serializerOptions,
            }),
        ];
    }
}

---

Your agent code stays the same - Tools = NativeAotTools.GetAllTools() just works.

What changes:

• no CreateDeclaration - Create() generates the schema from ReadFileArgs automatically
• no manual argument parsing - the framework deserializes into ReadFileArgs directly
• full NativeAOT support - NativeAotJsonContext provides compile-time serialization metadata
• tools are fully invocable - unlike AIFunctionDeclaration, the returned AIFunction can be called by the framework

[williamlzw]

internal class
Without defining this OllamaFunctionResultContent source generation context, it is not possible to receive the ReadFile result.

❌ 程序异常：JsonTypeInfo metadata for type 'OllamaSharp.MicrosoftAi.OllamaFunctionResultContent' was not provided by TypeInfoResolver of type 'OllamaJsonContext'. If using source generation, ensure that all root types passed to the serializer have been annotated with 'JsonSerializableAttribute', along with any types that might be serialized polymorphically. The unsupported member type is located on type 'OllamaSharp.Models.Chat.Message'. Path: $.Messages.

[williamlzw]

using Microsoft.Extensions.AI;
using SubAgent.Tools;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Text;
using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.Json.Serialization;
using static AgentProgram;

namespace SubAgent.Tools
{
    // ======================== 文件安全工具（与Python版功能一致） ========================
    public static class FileTools
    {
        private static readonly string _allowedBaseDir = Path.GetFullPath(Config.SAFE_ROOT);
        private static readonly HashSet<string> _allowedExtensions = new()
        {
            ".txt", ".md", ".json", ".csv", ".log", ".yaml", ".yml", ".py", ".js"
        };

        // 路径安全校验
        private static string ValidateFilePath(string filePath)
        {
            var targetPath = Path.GetFullPath(filePath);
            var basePath = Path.GetFullPath(_allowedBaseDir);

            if (!targetPath.StartsWith(basePath, StringComparison.OrdinalIgnoreCase))
                throw new UnauthorizedAccessException($"路径越权：仅允许操作 {basePath} 内的文件");

            var ext = Path.GetExtension(targetPath).ToLower();
            if (!_allowedExtensions.Contains(ext))
                throw new InvalidOperationException($"不支持的文件类型：{ext}");

            return targetPath;
        }

        private static string ValidateDirPath(string dirPath)
        {
            var targetPath = Path.GetFullPath(dirPath);
            var basePath = Path.GetFullPath(_allowedBaseDir);

            if (!targetPath.StartsWith(basePath, StringComparison.OrdinalIgnoreCase))
                throw new UnauthorizedAccessException($"路径越权：仅允许操作 {basePath} 内的目录");

            return targetPath;
        }

        [Description("读取文件内容")]
        public static string ReadFile(
            [Description("文件路径")] string filePath,
            [Description("编码")] string? encoding = null,
            [Description("文件不存在时自动创建")] bool createIfMissing = false)
        {
            try
            {
                var safePath = ValidateFilePath(filePath);
                encoding ??= "utf-8";

                if (!File.Exists(safePath))
                {
                    if (createIfMissing)
                    {
                        Directory.CreateDirectory(Path.GetDirectoryName(safePath)!);
                        File.WriteAllText(safePath, "", Encoding.GetEncoding(encoding));
                        return "";
                    }
                    throw new FileNotFoundException($"文件不存在：{safePath}");
                }

                return File.ReadAllText(safePath, Encoding.GetEncoding(encoding));
            }
            catch (Exception ex)
            {
                return $"读取文件失败：{ex.Message}";
            }
        }

        [Description("写入文件内容")]
        public static bool WriteFile(
            [Description("文件路径")] string filePath,
            [Description("写入内容")] string content,
            [Description("编码")] string? encoding = null,
            [Description("追加模式")] bool append = false,
            [Description("允许覆盖")] bool overwrite = true)
        {
            try
            {
                var safePath = ValidateFilePath(filePath);
                encoding ??= "utf-8";

                if (File.Exists(safePath) && !overwrite && !append)
                    throw new InvalidOperationException($"文件已存在且禁止覆盖：{safePath}");

                Directory.CreateDirectory(Path.GetDirectoryName(safePath)!);
                using var sw = new StreamWriter(safePath, append, Encoding.GetEncoding(encoding));
                sw.Write(content);
                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"写入文件失败：{ex.Message}");
                return false;
            }
        }

        //[Description("列举目录内容")]
        //public static List<Dictionary<string, object>> ListDirectory(
        //    [Description("目录路径")] string dirPath,
        //    [Description("递归遍历")] bool recursive = false)
        //{
        //    var result = new List<Dictionary<string, object>>();
        //    try
        //    {
        //        var safeDir = ValidateDirPath(dirPath);
        //        if (!Directory.Exists(safeDir))
        //            throw new DirectoryNotFoundException($"目录不存在：{safeDir}");

        //        var files = recursive ? Directory.EnumerateFiles(safeDir, "*.*", SearchOption.AllDirectories)
        //                              : Directory.EnumerateFiles(safeDir);
        //        var dirs = recursive ? Directory.EnumerateDirectories(safeDir, "*.*", SearchOption.AllDirectories)
        //                             : Directory.EnumerateDirectories(safeDir);

        //        foreach (var d in dirs)
        //        {
        //            result.Add(new Dictionary<string, object>
        //            {
        //                ["name"] = Path.GetFileName(d),
        //                ["path"] = d,
        //                ["is_file"] = false,
        //                ["is_dir"] = true,
        //                ["size"] = 0
        //            });
        //        }

        //        foreach (var f in files)
        //        {
        //            result.Add(new Dictionary<string, object>
        //            {
        //                ["name"] = Path.GetFileName(f),
        //                ["path"] = f,
        //                ["is_file"] = true,
        //                ["is_dir"] = false,
        //                ["size"] = new FileInfo(f).Length
        //            });
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        result.Add(new Dictionary<string, object> { ["error"] = ex.Message });
        //    }
        //    return result;
        //}

        [Description("创建目录")]
        public static bool CreateDirectory(
            [Description("目录路径")] string dirPath,
            [Description("已存在不报错")] bool existOk = true)
        {
            try
            {
                var safeDir = ValidateDirPath(dirPath);
                Directory.CreateDirectory(safeDir);
                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"创建目录失败：{ex.Message}");
                return false;
            }
        }

        [Description("创建空文件")]
        public static bool CreateEmptyFile(
            [Description("文件路径")] string filePath,
            [Description("允许覆盖")] bool overwrite = false)
        {
            try
            {
                var safePath = ValidateFilePath(filePath);
                if (File.Exists(safePath) && !overwrite)
                    throw new InvalidOperationException($"文件已存在且禁止覆盖：{safePath}");

                Directory.CreateDirectory(Path.GetDirectoryName(safePath)!);
                File.WriteAllText(safePath, "");
                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"创建空文件失败：{ex.Message}");
                return false;
            }
        }
    }


    internal static class ToolJsonUtilities
    {
        public static JsonSerializerOptions DefaultOptions { get; } = CreateDefaultOptions();

        private static JsonSerializerOptions CreateDefaultOptions()
        {
            var options = new JsonSerializerOptions(NativeAotJsonContext.Default.Options)
            {
                Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
            };
            options.TypeInfoResolverChain.Clear();
            options.TypeInfoResolverChain.Add(NativeAotJsonContext.Default);
            options.MakeReadOnly();
            return options;
        }
    }

    internal sealed class ReadFileArgs
    {
        [Description("文件路径")]
        [JsonPropertyName("file_path")]
        public required string FilePath { get; init; }

        [Description("编码")]
        [JsonPropertyName("encoding")]
        public string? Encoding { get; init; }

        [Description("文件不存在时自动创建")]
        [JsonPropertyName("create_if_missing")]
        public bool CreateIfMissing { get; init; }
    }

    internal sealed class WriteFileArgs
    {
        [Description("文件路径")]
        [JsonPropertyName("file_path")]
        public required string FilePath { get; init; }

        [Description("写入内容")]
        [JsonPropertyName("content")]
        public string Content { get; init; }

        [Description("编码")]
        [JsonPropertyName("encoding")]
        public string? Encoding { get; init; }

        [Description("追加模式")]
        [JsonPropertyName("append")]
        public bool Append { get; init; }

        [Description("允许覆盖")]
        [JsonPropertyName("overwrite")]
        public bool Overwrite { get; init; }
    }

    internal static class NativeAotTools
    {
        [Description("读取文件内容")]
        private static string ExecReadFile(ReadFileArgs args)
        {
            return FileTools.ReadFile(args.FilePath, args.Encoding, args.CreateIfMissing);
        }

        [Description("写入文件内容")]
        private static bool ExecWriteFile(WriteFileArgs args)
        {
            return FileTools.WriteFile(args.FilePath, args.Content, args.Encoding, args.Append, args.Overwrite);
        }

        public static List<AITool> GetAllTools()
        {
            var serializerOptions = ToolJsonUtilities.DefaultOptions;
            return
            [
                AIFunctionFactory.Create(ExecReadFile, new AIFunctionFactoryOptions
            {
                Name = "ReadFile",
                SerializerOptions = serializerOptions,
            }),
             AIFunctionFactory.Create(ExecWriteFile, new AIFunctionFactoryOptions
            {
                Name = "WriteFile",
                SerializerOptions = serializerOptions,
            }),
        ];
        }
    }
}

[JsonSourceGenerationOptions(
    JsonSerializerDefaults.Web,
    UseStringEnumConverter = true,
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    NumberHandling = JsonNumberHandling.AllowReadingFromString)]
[JsonSerializable(typeof(ReadFileArgs))]
[JsonSerializable(typeof(WriteFileArgs))]
internal sealed partial class NativeAotJsonContext : JsonSerializerContext;

[williamlzw]

using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;
using OllamaSharp;
using OllamaSharp.Models;
using OllamaSharp.Models.Chat;
using OpenAI;
using OpenAI.Chat;
using SubAgent.Tools;
using System.ClientModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Reflection;
using System.Text;
using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.Json.Serialization;
using OllamaSharp.MicrosoftAi;

#pragma warning disable MAAI001;
#pragma warning disable MEAI001;

[JsonSourceGenerationOptions(PropertyNameCaseInsensitive = true)]
//[JsonSerializable(typeof(OllamaSharp.MicrosoftAi.OllamaFunctionResultContent))]
[JsonSerializable(typeof(System.Text.Json.JsonElement))]
[JsonSerializable(typeof(System.Text.Json.Nodes.JsonObject))]
[JsonSerializable(typeof(OllamaSharp.Models.Chat.Message.Function))]
[JsonSerializable(typeof(OllamaSharp.Models.Chat.Function))]
[JsonSerializable(typeof(OllamaSharp.Models.Chat.Message))]
[JsonSerializable(typeof(OllamaSharp.Models.Chat.Parameters))]
[JsonSerializable(typeof(OllamaSharp.Models.Chat.Tool))]
[JsonSerializable(typeof(OllamaSharp.Models.Chat.ChatRequest))]
[JsonSerializable(typeof(OllamaSharp.Models.Chat.ChatResponseStream))]
[JsonSerializable(typeof(OllamaSharp.Models.Chat.ChatDoneResponseStream))]
[JsonSerializable(typeof(OllamaSharp.Models.Chat.ChatRole))]
[JsonSerializable(typeof(OllamaSharp.Models.Chat.ChatResponseStream))]
internal partial class OllamaJsonContext : JsonSerializerContext
{
    // 源生成器自动生成实现，无需手动编写
}


// 主程序入口
class AgentProgram
{
    // ======================== 全局终止标记 ========================
    private static bool _isShuttingDown = false;
    private static readonly CancellationTokenSource _cts = new();

    // ======================== 全局配置 ========================
    public static class Config
    {
        // 模型切换
        public static string SAFE_ROOT = "./data";
        // Ollama 配置
        public static string OLLAMA_MODEL => "Qwopus3.5-9B-coder-Q8:latest";
        public static string OLLAMA_API_URL => "http://localhost:11434/";

        public static string LLAMA_MODEL => "Qwopus3.5-9B-Coder-MTP-Q8_0";
        public static string LLAMA_API_URL => "http://localhost:8080/";

        // 路径配置
        public static string SKILLS_DIR => Path.Combine(AppContext.BaseDirectory, "skills");
  

        // Agent 指令（与Python版完全一致）
        public static string AGENT_INSTRUCTIONS => """
            You are a helpful assistant
            """;

        // 用户任务（与Python版一致）
        public static string USER_PROMPT => "你有哪些工具,读取d:/test123.txt内容输出来";
  
    }

    // ======================== 终端颜色 ========================
    public static class TerminalColor
    {
        public static void Reset() => Console.ResetColor();
        public static void Reasoning() => Console.ForegroundColor = ConsoleColor.Blue;
        public static void FunctionCall() => Console.ForegroundColor = ConsoleColor.DarkYellow;
        public static void FunctionResult() => Console.ForegroundColor = ConsoleColor.Green;
    }

    // ======================== Token性能统计器 ========================
    public class TokenPerformanceTracker
    {
        private Stopwatch? _stopwatch;
        private double _firstTokenLatency;
        private readonly List<double> _tokenIntervals = new();
        public int TotalTokens { get; private set; }

        public void Start()
        {
            _stopwatch = Stopwatch.StartNew();
            _firstTokenLatency = 0;
            _tokenIntervals.Clear();
            TotalTokens = 0;
        }

        public void RecordToken()
        {
            if (_stopwatch == null) return;

            if (_firstTokenLatency == 0)
            {
                _firstTokenLatency = _stopwatch.Elapsed.TotalSeconds;
            }
            else
            {
                _tokenIntervals.Add(_stopwatch.Elapsed.TotalSeconds);
            }

            _stopwatch.Restart();
            TotalTokens++;
        }

        public void PrintStats()
        {
            Console.WriteLine($"\n{new string('=', 30)} Ollama 流式性能统计 {new string('=', 30)}");
            Console.WriteLine($"首 Token 延迟: {_firstTokenLatency:F2}s");

            double avgIntervalMs = 0;
            double throughput = 0;
            if (_tokenIntervals.Count > 0)
            {
                avgIntervalMs = _tokenIntervals.Average() * 1000;
                throughput = 1000 / avgIntervalMs;
            }

            Console.WriteLine($"平均 Token 间隔: {avgIntervalMs:F2}ms");
            Console.WriteLine($"平均生成速度: {throughput:F2} tokens/s");
            Console.WriteLine($"总输出 Tokens: {TotalTokens}");
            Console.WriteLine($"{new string('=', 80)}");
        }
    }

    // ======================== 流式输出处理器 ========================
    public class StreamOutputHandler
    {
        private bool _lastIsReasoning;
        private bool _needNewLine;

        public void HandleContent(AIContent content)
        {
            if (_isShuttingDown) return;

            // 换行控制
            if (_lastIsReasoning && content is not TextReasoningContent)
            {
                _needNewLine = true;
                _lastIsReasoning = false;
            }

            if (_needNewLine)
            {
                Console.WriteLine();
                _needNewLine = false;
            }

            // 处理不同类型内容
            switch (content)
            {
                case TextReasoningContent reasoning:
                    HandleReasoning(reasoning.Text);
                    break;
                case TextContent text:
                    HandleText(text.Text);
                    break;
                case FunctionCallContent:
                    HandleFunctionCall();
                    break;
                case FunctionResultContent:
                    HandleFunctionResult();
                    break;
            }
        }

        private void HandleReasoning(string text)
        {
            TerminalColor.Reasoning();
            Console.Write(text);
            TerminalColor.Reset();
            Console.Out.Flush();
            _lastIsReasoning = true;
        }

        private void HandleText(string text)
        {
            Console.Write(text);
            Console.Out.Flush();
        }

        private void HandleFunctionCall()
        {
            TerminalColor.FunctionCall();
            Console.Write("[Function Call]");
            TerminalColor.Reset();
            Console.Out.Flush();
        }

        private void HandleFunctionResult()
        {
            TerminalColor.FunctionResult();
            Console.Write("[Function Result]");
            TerminalColor.Reset();
            Console.Out.Flush();
        }
    }


    // ======================== Agent工厂 ========================
    private static async Task<ChatClientAgent> CreateMainAgentAsync()
    {
        // 创建技能提供者
        //var skillsProvider = new AgentSkillsProvider(
        //    Path.GetFullPath(Config.SKILLS_DIR),
        //    SubprocessScriptRunner.RunAsync);
        var config = new OllamaApiClient.Configuration
        {
            Uri = new Uri(Config.OLLAMA_API_URL),
            Model = Config.OLLAMA_MODEL,
            JsonSerializerContext = OllamaJsonContext.Default
        };
        // 创建主客户端
        OllamaApiClient client = new OllamaApiClient(config);
        return client.AsAIAgent(new ChatClientAgentOptions
        {
            Name = "LeadAgent",
            ChatOptions = new ChatOptions
            {
                Instructions = Config.AGENT_INSTRUCTIONS,
                Reasoning = new() { Effort = ReasoningEffort.High },
                Tools = NativeAotTools.GetAllTools()
            },
            //AIContextProviders = [skillsProvider]
        });

        //var customBaseUrl = new Uri(Config.LLAMA_API_URL);
        //// 2. 配置 OpenAIClientOptions，设置 Endpoint
        //var openAIOptions = new OpenAIClientOptions
        //{
        //    Endpoint = customBaseUrl // 核心：覆盖默认 base URL
        //};

        //// 3. 初始化 OpenAIClient（带自定义端点与凭据）
        //var openAIClient = new OpenAIClient(
        //    credential: new ApiKeyCredential("123"),
        //    options: openAIOptions
        //);
        //// 创建主Agent
        //return openAIClient.GetChatClient(Config.LLAMA_MODEL).AsAIAgent(new ChatClientAgentOptions
        //{
        //    Name = "LeadAgent",
        //    ChatOptions = new ChatOptions
        //    {
        //        Instructions = Config.AGENT_INSTRUCTIONS,
        //        Reasoning = new() { Effort = ReasoningEffort.High }
        //    },
        //    //AIContextProviders = [skillsProvider]
        //});
    }

    // ======================== 优雅关闭 ========================
    private static void HandleShutdown(object? sender, ConsoleCancelEventArgs e)
    {
        e.Cancel = true;
        _isShuttingDown = true;
        _cts.Cancel();
        Console.WriteLine("\n\n⚠️  正在优雅停止Agent...");
    }

    // ======================== 主逻辑 ========================
    public static async Task Main(string[] args)
    {
    
        try
        {
            // 注册关闭信号
            Console.CancelKeyPress += HandleShutdown;
            Console.OutputEncoding = Encoding.UTF8; 
      

            // 初始化组件
            var mainAgent = await CreateMainAgentAsync();
            var perfTracker = new TokenPerformanceTracker();
            var outputHandler = new StreamOutputHandler();
            Console.WriteLine($"{new string('=', 30)} Agent 流式响应 {new string('=', 30)}");
            perfTracker.Start();

            // 流式执行主任务
            await foreach (var chunk in mainAgent.RunStreamingAsync(Config.USER_PROMPT, cancellationToken:_cts.Token))
            {
                if (_isShuttingDown) break;

                foreach (var content in chunk.Contents)
                {
                    outputHandler.HandleContent(content);

                    // 统计Token性能
                    if (content is TextContent)
                        perfTracker.RecordToken();
                }
            }

            // 打印性能统计
            if (!_isShuttingDown)
                perfTracker.PrintStats();

            Console.WriteLine("\n✅ 任务执行完成！");
            Console.ReadLine();
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("\n🛑 任务已取消");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"\n❌ 程序异常：{ex.Message}");
        }
        finally
        {
            _cts.Dispose();
            Console.ResetColor();
        }
    }
}

[awaescher]

@williamlzw I have seen several tickets from you here and in other (my) repositories. Sad to say that not even once I saw a ticket that was usable at all. Mostly uncommented and overly long code blocks so that noone knows what you are trying to report.

Examples:

• 5.2.2 OllamaSharp.Chat response think content and result content awaescher/OllamaSharp#264
• BUG:Think content is not printed awaescher/OllamaSharp#259
• parsing the think tag awaescher/OllamaSharp#242
• Does ollamasharp require tool call id? awaescher/OllamaSharp#224
• OllamaApiClient bug awaescher/OllamaSharp#217

---

Rule of thumb and general advice for life:

If you want to have someone else fixing stuff for you, lower the barrier to help as much as possible.

Don't expect others to spend significant amounts of their own life time guessing what your problem even is about - just because you are too lazy to tell.