AI 编辑器 CC for Unity

About OpenClaw

最近的龙虾神乎其神呀，OpenClaw 被众多人吹捧，一个 7 * 24 小时持续运行的 AI Agent 系统。

但是你了解它背后的秘密吗？其实很简单。

OpenClaw 的架构由三个模块组成：Agent Loop、Tools、Gateway。

• • Agent Loop：龙虾的大脑，它负责决策和思考，它会根据当前任务判断下一步要做什么，并在需要的时候调用各种工具来完成行动。
• • Tools：龙虾的手脚，为Agent Loop提供各种能力，比如浏览网页、执行命令、调用 API、处理文件等，让龙虾真正具备干活的能力。
• • Gateway：龙虾的身体，它让整个系统能够持续在线，接收来自不同渠道的消息（比如 Telegram、飞书等），并把任务交给Agent Loop处理，再把结果返回给用户。

其中 Agent Loop、Tools 并不是 OpenClaw 独有的，Claude Code 和 Codex 都有，Gateway 是 OpenClaw 独有的模块。

Gateway 只是持续在线通信的手段，并不在我们关心的范围。Agent Loop、Tools 的实现才是我们着重关注的。

而在 Claude Code 中也有，因此这里我打算在 Unity 中做一个极简版的 Claude Code。

带大家了解其背后的秘密，其实 AI 应用层它极其简单，一步一步实现出来，也许会震碎你三观…

和引擎一样，人工智能的底层逻辑才是 AI 的命脉，后续面向 AI-Infra 才是我个人开发实践的重点。

这篇文章也是我从游戏引擎过度人工智能的开始，后续会把学习的重心放在 AI 上，待 AI 小有所成后，回过头来继续游戏引擎、继续图形学。到时候用超魔法打败魔法~

回归正题，即《AI 编辑器 MCP for Unity》的后续之作，这次要开发的是 《AI 编辑器 Claude Code for Unity》。

Anthropic SDK CSharp

最初的打算是使用 C++ 来实现一个 Claude Code CLI，但考虑到时间成本，之前也已经实现了 MCP for Unity，而且 Anthropic SDK 没有 C++ 版（可以自己实现），有 C# 版本，如果能配合 CC for Unity，便可以轻松打造一个超强的智能体。

通过将 MCP for Unity 与 CC for Unity 结合使用，两者相辅相成，能够帮助开发者深入理解如何开发 AI 工具，并形成一个完整的闭环。

我只是抛砖引玉，如果感兴趣的话，可以沿着这个思路开发下去，做出自己心仪的 AI 产品。

Anthropic SDK 是 Anthropic 官方提供的开发工具包，旨在帮助开发者将 Claude 大语言模型无缝集成到自己的应用程序中。

这里提供 C# 版本的下载地址：https://github.com/anthropics/anthropic-sdk-csharp

当前最新的版本是 v12.8.0，但我下载的是 v10.4.0。

我使用的是 Unity 6.3 版本，因为当前 Unity 只支持 C# 9 版本，而 Anthropic SDK 已经支持到了 C# 12。本以为下载低版本的做降级会轻松些，事后发现我想多了…

不得不说为 Anthropic SDK 做降级还是花了一些心思的，但不是课程的重点，因此这里只做一下总结！

Unity 中使用 Anthropic SDK 的相关修改：

• • 代码降级到 C# 9
• • 删除 Microsoft.Extensions.AI 依赖
• • 清理不需要的目录（examples、tests等）
• • 下载必需的 DLL 文件（System.Text.Json.dll、System.Collections.Immutable.dll、System.Memory.dll、System.Buffers.dll 等）如何下载 DLL？使用 NuGet 命令行：

  nuget install System.Text.Json -Version 4.7.2
  nuget install System.Collections.Immutable -Version 8.0.0

• • System.Text.Json 兼容性修复

改动还是蛮多的…

Claude Code for Unity

在后续的开发过程中，你会发现，这里只用到了 Anthropic SDK 的 token 验证和模型交互功能。

其余的都是自己实现的，这样跟着看下来，你会对 AI Agent 开发有个整体的认知。

而且这部分代码可以完全剥离 Unity 依赖，你也可以单独提炼出来在 dotnet 以命令行去实现。

Agent Loop

Agent Loop，是 AI 接到一个任务之后，自己一步一步把事情做完的机制。

实践上它就是一个循环体，是一个和 AI 不停交互的过程，这就是 Agent Loop。

因为我想一次性在文章讲完，虽然代码不复杂但还是有些体量的，就直接贴全码了，不讲究开发阶段过程了

AgentLoop.cs

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using Anthropic;
using Anthropic.Models.Messages;

namespaceClaudeCodeForUnity
{
publicclassAgentLoop
    {
privatereadonly AnthropicClient _client;
privatereadonlystring _model;
privatereadonlystring _systemPrompt;
privatereadonly ToolManager _skillAgent;
privatereadonly BackgroundManager _backgroundTaskManager;
private ToolManager.SkillType _skillType;
private List<MessageParam> _conversationHistory;
privatelong _totalInputTokens;
privatelong _totalOutputTokens;

publicevent System.Action<long, long, long> OnTokenUsageUpdated;

publicAgentLoop(AnthropicClient client, string model, string systemPrompt,
                         ToolManager skillAgent, ToolManager.SkillType skillType = ToolManager.SkillType.Code,
                         BackgroundManager backgroundTaskManager = null)
        {
            _client = client;
            _model = model;
            _systemPrompt = systemPrompt;
            _skillAgent = skillAgent;
            _skillType = skillType;
            _backgroundTaskManager = backgroundTaskManager;
            _conversationHistory = new List<MessageParam>();
        }

public IReadOnlyList<MessageParam> ConversationHistory => _conversationHistory;

publicvoidClearHistory()
        {
            _conversationHistory.Clear();
        }

publicasync Task<string> ProcessMessageAsync(string userMessage, CancellationToken cancellationToken = default)
        {
// 添加用户消息到历史
            _conversationHistory.Add(new MessageParam
            {
                Role = Role.User,
                Content = userMessage
            });

// 运行代理循环
var result = await RunAgentLoopAsync(cancellationToken);

// 提取最终的文本响应
return ExtractTextResponse(result);
        }

privateasync Task<List<ContentBlockParam>> RunAgentLoopAsync(CancellationToken cancellationToken = default)
        {
var tools = _skillAgent.GetToolsForSkill(_skillType);

while (true)
            {
// 检查取消请求
                cancellationToken.ThrowIfCancellationRequested();
// 0. 排空后台任务通知队列，将完成的任务结果注入对话
if (_backgroundTaskManager != null)
                {
var notifications = _backgroundTaskManager.DrainNotifications();
if (notifications.Count > 0 && _conversationHistory.Count > 0)
                    {
var notifText = string.Join("\n",
                            notifications.Select(n => $"[bg:{n.TaskId}] {n.Status}: {n.Result}"));

// 注入后台结果作为用户消息
                        _conversationHistory.Add(new MessageParam
                        {
                            Role = Role.User,
                            Content = $"<background-results>\n{notifText}\n</background-results>"
                        });

// 助手确认
                        _conversationHistory.Add(new MessageParam
                        {
                            Role = Role.Assistant,
                            Content = "Noted background results."
                        });

                        UnityEngine.Debug.Log($"[Background Notifications] Injected {notifications.Count} completed task(s)");
                    }
                }

// 1. 调用模型
var response = await _client.Messages.Create(new MessageCreateParams
                {
                    Model = _model,
                    Messages = _conversationHistory,
                    System = _systemPrompt,
                    Tools = tools.Select(t => (ToolUnion)t).ToList(),
                    MaxTokens = 4096
                });

// 更新 token 使用统计
if (response.Usage != null)
                {
                    _totalInputTokens += response.Usage.InputTokens;
                    _totalOutputTokens += response.Usage.OutputTokens;
var totalTokens = _totalInputTokens + _totalOutputTokens;

// 触发事件通知UI更新
                    OnTokenUsageUpdated?.Invoke(_totalInputTokens, _totalOutputTokens, totalTokens);

                    UnityEngine.Debug.Log($"[Token Usage] Input: {response.Usage.InputTokens}, Output: {response.Usage.OutputTokens}, Total Session: {totalTokens}");
                }

// 2. 收集工具调用和文本输出
var toolCalls = new List<ToolUseBlock>();
var textOutput = new List<string>();

foreach (var block in response.Content)
                {
if (block.TryPickText(outvar text))
                        textOutput.Add(text.Text);

if (block.TryPickThinking(outvar thinking))
                    {
// 记录思考内容（可选显示）
                        UnityEngine.Debug.Log($"[AI Thinking] {thinking.Thinking}");
                    }

if (block.TryPickToolUse(outvar toolUse))
                        toolCalls.Add(toolUse);
                }

// 3. 如果没有工具调用，任务完成
if (response.StopReason != StopReason.ToolUse)
                {
// 将助手响应添加到历史
var assistantContent = ConvertContentBlocks(response.Content);
                    _conversationHistory.Add(new MessageParam
                    {
                        Role = Role.Assistant,
                        Content = assistantContent
                    });

return assistantContent;
                }

// 4. 执行每个工具并收集结果
var toolResults = new List<ToolResultBlockParam>();
foreach (var toolCall in toolCalls)
                {
var output = await _skillAgent.ExecuteToolAsync(toolCall.Name, toolCall.Input);
                    toolResults.Add(new ToolResultBlockParam
                    {
                        ToolUseID = toolCall.ID,
                        Content = output
                    });
                }

// 5. 将助手消息和工具结果添加到历史，继续循环
var assistantBlocks = ConvertContentBlocks(response.Content);
                _conversationHistory.Add(new MessageParam
                {
                    Role = Role.Assistant,
                    Content = assistantBlocks
                });

                _conversationHistory.Add(new MessageParam
                {
                    Role = Role.User,
                    Content = toolResults.Select(r => (ContentBlockParam)r).ToList()
                });
            }
        }

privatestringExtractTextResponse(List<ContentBlockParam> contentBlocks)
        {
var textResponse = new System.Text.StringBuilder();

foreach (var block in contentBlocks)
            {
if (block.TryPickText(outvar textBlock))
                {
                    textResponse.AppendLine(textBlock.Text);
                }
// 可选：显示思考内容（DeepSeek Reasoner）
// else if (block.TryPickThinking(out var thinkingBlock))
// {
//     textResponse.AppendLine($"[Thinking: {thinkingBlock.Thinking}]");
// }
            }

return textResponse.ToString().Trim();
        }

private List<ContentBlockParam> ConvertContentBlocks(IEnumerable<ContentBlock> contentBlocks)
        {
var result = new List<ContentBlockParam>();

foreach (var block in contentBlocks)
            {
if (block.TryPickText(outvar textBlock))
                {
                    result.Add(new TextBlockParam { Text = textBlock.Text });
                }
elseif (block.TryPickThinking(outvar thinkingBlock))
                {
// 处理 thinking 块（DeepSeek Reasoner 需要）
                    result.Add(new ThinkingBlockParam
                    {
                        Signature = thinkingBlock.Signature,
                        Thinking = thinkingBlock.Thinking
                    });
                }
elseif (block.TryPickToolUse(outvar toolUseBlock))
                {
                    result.Add(new ToolUseBlockParam
                    {
                        ID = toolUseBlock.ID,
                        Name = toolUseBlock.Name,
                        Input = toolUseBlock.Input
                    });
                }
            }

return result;
        }

publicvoidSetSystemPrompt(string systemPrompt)
        {
// 注意：系统提示在每次API调用时传递，这里只是存储
// 实际使用时需要在RunAgentLoopAsync中传递
        }

publicvoidSetSkillType(ToolManager.SkillType skillType)
        {
// 技能类型影响可用工具，需要在下次循环中生效
            _skillType = skillType;
        }
    }
}

Bash Agent

Bash 就是一切 – 最简 Agent 的哲学。

构建了各种复杂的 Agent 系统后，我们追问一个根本问题：Agent 的本质是什么？

答案令人惊讶地简单：一个工具 + 一个循环 = 完整的 Agent 能力。

Unix 哲学说”一切皆文件，一切皆可管道”。Bash 是通往这个世界的大门，让我们来实现一个 Bash Agent 吧！

BashAgent.cs

using System;
using System.Diagnostics;
using System.Threading.Tasks;
using System.Linq;
using System.Threading;

namespaceClaudeCodeForUnity
{
publicclassBashAgent
    {
privatereadonlystring _workingDirectory;
privatereadonlyint _timeoutSeconds;

publicBashAgent(string workingDirectory, int timeoutSeconds = 60)
        {
            _workingDirectory = workingDirectory;
            _timeoutSeconds = timeoutSeconds;
        }

privateasync Task WaitForProcessExitAsync(Process process, CancellationToken cancellationToken)
        {
while (!process.HasExited && !cancellationToken.IsCancellationRequested)
            {
await Task.Delay(100, cancellationToken);
            }

if (!process.HasExited)
            {
                process.Kill();
            }
        }

publicasync Task<string> ExecuteAsync(string command)
        {
// 安全检查 - 阻止危险命令
string[] dangerousCommands = { "rm -rf /", "sudo", "shutdown", "reboot", "> /dev/" };
if (dangerousCommands.Any(d => command.Contains(d)))
return"Error: 危险命令已阻止";

try
            {
usingvar process = new Process
                {
                    StartInfo = new ProcessStartInfo
                    {
                        FileName = "bash",
                        Arguments = $"-c \"{command.Replace("\"", "\\\"")}\"",
                        WorkingDirectory = _workingDirectory,
                        RedirectStandardOutput = true,
                        RedirectStandardError = true,
                        UseShellExecute = false,
                        CreateNoWindow = true
                    }
                };

                process.Start();
var stdout = await process.StandardOutput.ReadToEndAsync();
var stderr = await process.StandardError.ReadToEndAsync();

usingvar cts = new CancellationTokenSource(TimeSpan.FromSeconds(_timeoutSeconds));
await WaitForProcessExitAsync(process, cts.Token);

var output = (stdout + stderr).Trim();
returnstring.IsNullOrEmpty(output) ? "(no output)" : SafeSubstring(output, 50000);
            }
catch (OperationCanceledException)
            {
return$"Error: 命令超时 ({_timeoutSeconds}s)";
            }
catch (Exception ex)
            {
return$"Error: {ex.Message}";
            }
        }

publicstringExecute(string command)
        {
// 安全检查
string[] dangerousCommands = { "rm -rf /", "sudo", "shutdown", "reboot", "> /dev/" };
if (dangerousCommands.Any(d => command.Contains(d)))
return"Error: 危险命令已阻止";

try
            {
usingvar process = new Process
                {
                    StartInfo = new ProcessStartInfo
                    {
                        FileName = "bash",
                        Arguments = $"-c \"{command.Replace("\"", "\\\"")}\"",
                        WorkingDirectory = _workingDirectory,
                        RedirectStandardOutput = true,
                        RedirectStandardError = true,
                        UseShellExecute = false,
                        CreateNoWindow = true
                    }
                };

                process.Start();
var stdout = process.StandardOutput.ReadToEnd();
var stderr = process.StandardError.ReadToEnd();

// 设置超时
if (!process.WaitForExit(_timeoutSeconds * 1000))
                {
                    process.Kill();
return"Error: 命令超时";
                }

var output = (stdout + stderr).Trim();
returnstring.IsNullOrEmpty(output) ? "(no output)" : SafeSubstring(output, 50000);
            }
catch (Exception ex)
            {
return$"Error: {ex.Message}";
            }
        }

privatestringSafeSubstring(string text, int maxLength)
        {
if (string.IsNullOrEmpty(text) || text.Length <= maxLength)
return text;

return text.Substring(0, maxLength);
        }
    }
}

File Agent

模型即代理 – 4 个工具覆盖 90% 场景。

因此产生了 File Agent，实现一些文件读写操作。

FileAgent.cs

using System;
using System.IO;
using System.Linq;

namespaceClaudeCodeForUnity
{
publicclassFileAgent
    {
privatereadonlystring _workingDirectory;

publicFileAgent(string workingDirectory)
        {
            _workingDirectory = workingDirectory;
        }

publicstringReadFile(string relativePath, int? limit = null)
        {
try
            {
var fullPath = GetSafePath(relativePath);
var lines = File.ReadAllLines(fullPath);

if (limit.HasValue && limit.Value < lines.Length)
                {
                    lines = lines.Take(limit.Value)
                        .Concat(new[] { $"... ({lines.Length - limit.Value} more lines)" })
                        .ToArray();
                }

var result = string.Join("\n", lines);
return SafeSubstring(result, 50000);
            }
catch (Exception ex)
            {
return$"Error: {ex.Message}";
            }
        }

publicstringWriteFile(string relativePath, string content)
        {
try
            {
var fullPath = GetSafePath(relativePath);
var dir = Path.GetDirectoryName(fullPath);

if (!string.IsNullOrEmpty(dir))
                    Directory.CreateDirectory(dir);

                File.WriteAllText(fullPath, content);
return$"Wrote {content.Length} bytes to {relativePath}";
            }
catch (Exception ex)
            {
return$"Error: {ex.Message}";
            }
        }

publicstringEditFile(string relativePath, string oldText, string newText)
        {
try
            {
var fullPath = GetSafePath(relativePath);
var fileContent = File.ReadAllText(fullPath);

if (!fileContent.Contains(oldText))
return$"Error: 在 {relativePath} 中未找到文本";

// 只替换第一次出现，保证安全
var index = fileContent.IndexOf(oldText);
if (index == -1)
return$"Error: 在 {relativePath} 中未找到文本";

var newContent = fileContent.Substring(0, index) +
                                newText +
                                fileContent.Substring(index + oldText.Length);

                File.WriteAllText(fullPath, newContent);
return$"Edited {relativePath}";
            }
catch (Exception ex)
            {
return$"Error: {ex.Message}";
            }
        }

publicboolFileExists(string relativePath)
        {
try
            {
var fullPath = GetSafePath(relativePath);
return File.Exists(fullPath);
            }
catch
            {
returnfalse;
            }
        }

///<exception cref="InvalidOperationException">路径逃逸工作目录</exception>
privatestringGetSafePath(string relativePath)
        {
var fullPath = Path.GetFullPath(Path.Combine(_workingDirectory, relativePath));
if (!fullPath.StartsWith(_workingDirectory))
thrownew InvalidOperationException($"路径逃逸工作区: {relativePath}");
return fullPath;
        }

privatestringSafeSubstring(string text, int maxLength)
        {
if (string.IsNullOrEmpty(text) || text.Length <= maxLength)
return text;

return text.Substring(0, maxLength);
        }
    }
}

Todo Manager

当下的 AI 编辑器，都提供了规划计划的能力，OK~ 接下来我们也要实现此功能了。

TodoManager.cs

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;

namespaceClaudeCodeForUnity
{
publicclassTodoManager
    {
private List<TodoItem> _items = new List<TodoItem>();

publicevent System.Action OnTodoListUpdated;

publicstringUpdate(JsonElement itemsJson)
        {
var validated = new List<TodoItem>();
var inProgressCount = 0;

foreach (var item in itemsJson.EnumerateArray())
            {
var content = item.TryGetProperty("content", outvar c) ? c.GetString()?.Trim() ?? "" : "";
var status = item.TryGetProperty("status", outvar s) ? s.GetString()?.ToLower() ?? "pending" : "pending";
var activeForm = item.TryGetProperty("activeForm", outvar a) ? a.GetString()?.Trim() ?? "" : "";

if (string.IsNullOrEmpty(content))
thrownew System.InvalidOperationException($"Item: content required");
if (status isnot ("pending"or"in_progress"or"completed"))
thrownew System.InvalidOperationException($"Item: invalid status '{status}'");

// 如果 activeForm 为空，使用 content 作为默认值
if (string.IsNullOrEmpty(activeForm))
                    activeForm = content;

if (status == "in_progress")
                    inProgressCount++;

                validated.Add(new TodoItem(content, status, activeForm));
            }

if (validated.Count > 20)
thrownew System.InvalidOperationException("Max 20 todos allowed");
if (inProgressCount > 1)
thrownew System.InvalidOperationException("Only one task can be in_progress at a time");

            _items = validated;

// 触发更新事件
            OnTodoListUpdated?.Invoke();

return Render();
        }

publicstringRender()
        {
if (_items.Count == 0)
return"No todos.";

var sb = new StringBuilder();
foreach (var item in _items)
            {
var mark = item.Status switch
                {
"completed" => "[x]",
"in_progress" => "[>]",
                    _ => "[ ]"
                };

if (item.Status == "in_progress")
                    sb.AppendLine($"{mark}{item.Content} <- {item.ActiveForm}");
else
                    sb.AppendLine($"{mark}{item.Content}");
            }

var completed = _items.Count(t => t.Status == "completed");
            sb.AppendLine($"\n({completed}/{_items.Count} completed)");
return sb.ToString();
        }

publicvoidClear()
        {
            _items.Clear();
            OnTodoListUpdated?.Invoke();
        }

public IReadOnlyList<TodoItem> Items => _items;
    }

publicclassTodoItem
    {
publicstring Content { get; }

publicstring Status { get; }

publicstring ActiveForm { get; }

publicTodoItem(string content, string status, string activeForm)
        {
            Content = content;
            Status = status;
            ActiveForm = activeForm;
        }
    }
}

Sub Agent

有了计划功能的加入，我们要设计对应的三个子代理模式了，它们分其责，

SubAgentManager.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using Anthropic;
using Anthropic.Models.Messages;

namespaceClaudeCodeForUnity
{
publicclassSubAgentManager
    {
privatereadonlystring _workingDirectory;
privatereadonly AnthropicClient _client;
privatereadonlystring _model;

publicclassSubAgentConfig
        {
publicstring Name { get; set; }

publicstring Description { get; set; }

publicstring[] AllowedTools { get; set; }

publicstring SystemPrompt { get; set; }

publicSubAgentConfig(string name, string description, string[] allowedTools, string systemPrompt)
            {
                Name = name;
                Description = description;
                AllowedTools = allowedTools;
                SystemPrompt = systemPrompt;
            }
        }

privatereadonly Dictionary<string, SubAgentConfig> _agentConfigs = new()
        {
            ["explore"] = new SubAgentConfig(
"explore",
"只读代理，用于探索代码、查找文件、搜索",
new[] { "bash", "read_file" },
"你是一个探索代理。搜索和分析，但不要修改文件。返回简洁的摘要。"
            ),
            ["code"] = new SubAgentConfig(
"code",
"完整代理，用于实现功能和修复bug",
new[] { "*" }, // 所有工具
"你是一个编程代理。高效地实现请求的更改。"
            ),
            ["plan"] = new SubAgentConfig(
"plan",
"规划代理，用于设计实现策略",
new[] { "bash", "read_file" },
"你是一个规划代理。分析代码库并输出编号的实现计划。不要做更改。"
            )
        };

publicSubAgentManager(string workingDirectory, AnthropicClient client, string model)
        {
            _workingDirectory = workingDirectory;
            _client = client;
            _model = model;
        }

publicasync Task<string> ExecuteSubAgentAsync(string description, string prompt, string agentType,
            List<Tool> availableTools)
        {
if (!_agentConfigs.TryGetValue(agentType, outvar config))
return$"Error: 未知agent类型 '{agentType}'";

// 过滤工具列表
var filteredTools = FilterTools(availableTools, config.AllowedTools);

// 创建子代理系统提示
var subSystemPrompt = $@"你是一个位于 {_workingDirectory} 的 {agentType} 子代理。

{config.SystemPrompt}

完成任务并返回清晰简洁的摘要。";

// 创建独立的对话历史
var subHistory = new List<MessageParam>
            {
new MessageParam { Role = Role.User, Content = prompt }
            };

var startTime = DateTime.Now;
var toolCount = 0;

// 运行子代理循环
while (true)
            {
var response = await _client.Messages.Create(new MessageCreateParams
                {
                    Model = _model,
                    Messages = subHistory,
                    System = subSystemPrompt,
                    Tools = filteredTools.Select(t => (ToolUnion)t).ToList(),
                    MaxTokens = 4096
                });

// 如果没有工具调用，返回最终文本
if (response.StopReason != StopReason.ToolUse)
                {
var elapsed = (DateTime.Now - startTime).TotalSeconds;
return FormatResult(response, toolCount, elapsed);
                }

// 执行工具调用
var toolCalls = response.Content
                    .Where(c => c.TryPickToolUse(out _))
                    .Select(c => { c.TryPickToolUse(outvar tu); return tu!; })
                    .ToList();

var toolResults = new List<ToolResultBlockParam>();

foreach (var toolCall in toolCalls)
                {
                    toolCount++;
// 注意：这里需要实际的工具执行逻辑
// 由于工具执行依赖于主代理的ToolManager，这里返回模拟结果
var output = $"[子代理工具执行: {toolCall.Name}]";
                    toolResults.Add(new ToolResultBlockParam
                    {
                        ToolUseID = toolCall.ID,
                        Content = output
                    });
                }

// 更新对话历史
var assistantBlocks = response.Content.Select<ContentBlock, ContentBlockParam>(c =>
                {
if (c.TryPickText(outvar t)) returnnew TextBlockParam { Text = t.Text };
if (c.TryPickThinking(outvar thinking)) returnnew ThinkingBlockParam
                    {
                        Signature = thinking.Signature,
                        Thinking = thinking.Thinking
                    };
if (c.TryPickToolUse(outvar tu)) returnnew ToolUseBlockParam
                    {
                        ID = tu.ID,
                        Name = tu.Name,
                        Input = tu.Input
                    };
thrownew InvalidOperationException("Unknown content block type");
                }).ToList();

                subHistory.Add(new MessageParam { Role = Role.Assistant, Content = assistantBlocks });
                subHistory.Add(new MessageParam
                {
                    Role = Role.User,
                    Content = toolResults.Select(r => (ContentBlockParam)r).ToList()
                });
            }
        }

private List<Tool> FilterTools(List<Tool> allTools, string[] allowedTools)
        {
if (allowedTools.Contains("*"))
return allTools;

return allTools.Where(t => allowedTools.Contains(t.Name)).ToList();
        }

privatestringFormatResult(Message response, int toolCount, double elapsedSeconds)
        {
var textBlocks = response.Content
                .Where(c => c.TryPickText(out _))
                .Select(c => { c.TryPickText(outvar t); return t!.Text; })
                .ToList();

var result = string.Join("", textBlocks);
return$"[子代理完成] 工具调用: {toolCount}次, 耗时: {elapsedSeconds:F1}秒\n\n{result}";
        }

public Dictionary<string, string> GetAgentDescriptions()
        {
return _agentConfigs.ToDictionary(
                kv => kv.Key,
                kv => kv.Value.Description
            );
        }

publicboolAgentTypeExists(string agentType)
        {
return _agentConfigs.ContainsKey(agentType);
        }

publicvoidAddAgentConfig(string name, string description, string[] allowedTools, string systemPrompt)
        {
            _agentConfigs[name] = new SubAgentConfig(name, description, allowedTools, systemPrompt);
        }
    }
}

Skill Agent

Agent Skills 确实是最近AI领域最火爆的概念之一。也是 OpenClaw 的“灵魂”与“工具箱”。

工具是能力，技能是知识。Skills 机制便是知识外部化。

SKILL.md 标准

skills/
├── pdf/
│   └── SKILL.md          # 必需：YAML frontmatter + Markdown
├── mcp-builder/
│   ├── SKILL.md
│   └── references/       # 可选：参考文档
└── code-review/
    ├── SKILL.md
    └── scripts/          # 可选：辅助脚本

SKILL.md 格式

---
name: my-skill
description: 简短描述，用于触发判断。
---

# My Skill

## 什么时候使用

当用户需要...

## 如何使用

### 模式 1: ...

```bash
example command

具体细节这里就不做讲解，网上很多现成的 Skill ，直接拿来主义即可。

SkillLoader.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;

namespaceClaudeCodeForUnity
{
publicclassSkillLoader
    {
publicclassSkill
        {
publicstring Name { get; }
publicstring Description { get; }
publicstring Body { get; }
publicstring Path { get; }
publicstring Directory { get; }

publicSkill(string name, string description, string body, string path, string directory)
            {
                Name = name;
                Description = description;
                Body = body;
                Path = path;
                Directory = directory;
            }
        }

privatereadonlystring _skillsDirectory;
privatereadonly Dictionary<string, Skill> _skills = new Dictionary<string, Skill>();

publicSkillLoader(string skillsDirectory)
        {
            _skillsDirectory = skillsDirectory;
            LoadSkills();
        }

private Skill ParseSkillMd(string path)
        {
var content = File.ReadAllText(path);

// 匹配 YAML frontmatter: ---\n...\n---\n
var match = Regex.Match(content, @"^---\s*\n(.*?)\n---\s*\n(.*)$",
                RegexOptions.Singleline);

if (!match.Success)
            {
                UnityEngine.Debug.LogWarning($"[SkillLoader] Invalid SKILL.md format: {path}");
returnnull;
            }

var frontmatter = match.Groups[1].Value;
var body = match.Groups[2].Value.Trim();

// 解析 YAML frontmatter
var metadata = new Dictionary<string, string>();
foreach (var line in frontmatter.Split('\n'))
            {
var colonIndex = line.IndexOf(':');
if (colonIndex > 0)
                {
var key = line.Substring(0, colonIndex).Trim();
varvalue = line.Substring(colonIndex + 1).Trim().Trim('"', '\'');
                    metadata[key] = value;
                }
            }

if (!metadata.TryGetValue("name", outvar name) ||
                !metadata.TryGetValue("description", outvar description))
            {
                UnityEngine.Debug.LogWarning($"[SkillLoader] Missing name or description in: {path}");
returnnull;
            }

var directory = System.IO.Path.GetDirectoryName(path);
returnnew Skill(name, description, body, path, directory);
        }

privatevoidLoadSkills()
        {
if (!System.IO.Directory.Exists(_skillsDirectory))
            {
                UnityEngine.Debug.LogWarning($"[SkillLoader] Skills directory not found: {_skillsDirectory}");
return;
            }

var skillDirs = System.IO.Directory.GetDirectories(_skillsDirectory);
foreach (var skillDir in skillDirs)
            {
var skillMdPath = System.IO.Path.Combine(skillDir, "SKILL.md");
if (!File.Exists(skillMdPath))
continue;

var skill = ParseSkillMd(skillMdPath);
if (skill != null)
                {
                    _skills[skill.Name] = skill;
                    UnityEngine.Debug.Log($"[SkillLoader] Loaded skill: {skill.Name} - {skill.Description}");
                }
            }

            UnityEngine.Debug.Log($"[SkillLoader] Total skills loaded: {_skills.Count}");
        }

publicstringGetDescriptions()
        {
if (_skills.Count == 0)
return"(no skills available)";

var descriptions = _skills.Select(kv => $"- {kv.Key}: {kv.Value.Description}");
returnstring.Join("\n", descriptions);
        }

publicstringGetSkillContent(string name)
        {
if (!_skills.TryGetValue(name, outvar skill))
returnnull;

var content = $"# Skill: {skill.Name}\n\n{skill.Body}";

// 检查可用资源
var resources = new List<string>();
var resourceFolders = new[]
            {
                ("scripts", "Scripts"),
                ("references", "References"),
                ("assets", "Assets")
            };

foreach (var (folder, label) in resourceFolders)
            {
var folderPath = System.IO.Path.Combine(skill.Directory, folder);
if (System.IO.Directory.Exists(folderPath))
                {
var files = System.IO.Directory.GetFiles(folderPath)
                        .Select(System.IO.Path.GetFileName);

if (files.Any())
                        resources.Add($"{label}: {string.Join(", ", files)}");
                }
            }

// 添加资源信息
if (resources.Count > 0)
            {
                content += $"\n\n**Available resources in {skill.Directory}:**\n";
                content += string.Join("\n", resources.Select(r => $"- {r}"));
            }

return content;
        }

public IEnumerable<string> ListSkills()
        {
return _skills.Keys;
        }

publicint SkillCount => _skills.Count;

publicboolHasSkill(string name)
        {
return _skills.ContainsKey(name);
        }
    }
}

SkillAgent.cs

using System;
using System.Collections.Generic;
using System.Linq;

namespaceClaudeCodeForUnity
{
publicclassSkillAgent
    {
privatereadonly SkillLoader _skillLoader;

publicSkillAgent(SkillLoader skillLoader)
        {
            _skillLoader = skillLoader ?? thrownew ArgumentNullException(nameof(skillLoader));
        }

publicstringGetSkillDescriptions()
        {
return _skillLoader.GetDescriptions();
        }

public IEnumerable<string> ListSkills()
        {
return _skillLoader.ListSkills();
        }

publicboolHasSkill(string skillName)
        {
return _skillLoader.HasSkill(skillName);
        }

publicstringLoadSkill(string skillName)
        {
if (string.IsNullOrEmpty(skillName))
            {
return"Error: skill name cannot be empty";
            }

var content = _skillLoader.GetSkillContent(skillName);

if (content == null)
            {
var available = string.Join(", ", ListSkills());
return$"Error: Unknown skill '{skillName}'. Available: {(string.IsNullOrEmpty(available) ? "none" : available)}";
            }

// 关键机制：以 tool_result 形式注入，不修改系统提示（保持 prompt cache）
return$@"<skill-loaded name=""{skillName}"">
{content}
</skill-loaded>

按照上面技能中的指令完成用户的任务。";
        }

publicint SkillCount => _skillLoader.SkillCount;

public SkillLoader SkillLoader => _skillLoader;
    }
}

Task Manager

任务管理实际要解决的是上下文压缩和记忆功能。

上下文窗口有限，但智能体会话可以无限。

三层压缩在不同粒度上解决这个问题：

• • MicroCompact（替换旧工具输出）- 静默替换
• • AutoCompact（接近限制时 LLM 摘要）- 阈值触发
• • Manual Compact（用户触发）- 手动触发

分层方法让每一层在各自的粒度上独立运作，从静默的逐轮清理到完整的对话重置。

有了压缩功能，要面对另一个问题，当对话被压缩时，所有的任务状态都丢失了。

这里使用文件系统是最简单的持久化方案：无需数据库，无需序列化框架，JSON + 文件目录就是一个功能完整的任务看板。

TaskManager.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using Anthropic;
using Anthropic.Models.Messages;

namespaceClaudeCodeForUnity
{
publicclassTaskManager
    {
privatereadonly AnthropicClient _client;
privatereadonlystring _model;
privatereadonly TodoManager _todoManager;
privatereadonlystring _workDir;
privatereadonlystring _transcriptDir;
privatereadonlystring _tasksDir;

// 压缩参数
privateconstint TOKEN_THRESHOLD = 50000;  // Token 阈值
privateconstint KEEP_RECENT = 3;          // 保留最近 N 个工具结果

// 工具结果追踪器: 记录哪些消息包含 tool_result 及其 ID 和工具名
privatereadonly List<(int msgIdx, List<(string toolUseId, string toolName)> tools)> _toolResultTracker
            = new List<(int, List<(string, string)>)>();

// 任务 ID 计数器
privateint _nextTaskId;

publicevent Action<string, string> OnCompactCompleted;

publicevent Action<int> OnTokenEstimateUpdated;

publicevent Action<int, string> OnTaskCreated;

publicevent Action<int, string> OnTaskUpdated;

publicTaskManager(AnthropicClient client, string model, TodoManager todoManager, string workDir)
        {
            _client = client ?? thrownew ArgumentNullException(nameof(client));
            _model = model ?? thrownew ArgumentNullException(nameof(model));
            _todoManager = todoManager ?? thrownew ArgumentNullException(nameof(todoManager));
            _workDir = workDir ?? Directory.GetCurrentDirectory();
            _transcriptDir = Path.Combine(_workDir, ".transcripts");
            _tasksDir = Path.Combine(_workDir, ".tasks");

// 初始化任务系统
            Directory.CreateDirectory(_tasksDir);
            _nextTaskId = GetMaxTaskId() + 1;

            UnityEngine.Debug.Log($"[TaskManager] Initialized with tasks directory: {_tasksDir}");
            UnityEngine.Debug.Log($"[TaskManager] Next task ID: {_nextTaskId}");
        }

privatestatic JsonElement SerializeToElement<T>(T value)
        {
var json = JsonSerializer.Serialize(value);
usingvar doc = JsonDocument.Parse(json);
return doc.RootElement.Clone();
        }

publicintEstimateTokens(List<MessageParam> messages)
        {
var json = JsonSerializer.Serialize(messages);
var estimate = json.Length / 4;
            OnTokenEstimateUpdated?.Invoke(estimate);
return estimate;
        }

publicvoidMicroCompact(List<MessageParam> messages)
        {
if (_toolResultTracker.Count <= KEEP_RECENT)
return;

var toClear = _toolResultTracker.Take(_toolResultTracker.Count - KEEP_RECENT).ToList();
foreach (var (msgIdx, tools) in toClear)
            {
if (msgIdx >= messages.Count)
continue;

// 用包含占位符内容的新 ToolResultBlockParam 替换整条消息
var newBlocks = tools.Select(t => (ContentBlockParam)new ToolResultBlockParam
                {
                    ToolUseID = t.toolUseId,
                    Content = $"[Previous: used {t.toolName}]"
                }).ToList();

                messages[msgIdx] = new MessageParam
                {
                    Role = Role.User,
                    Content = newBlocks
                };
            }

            UnityEngine.Debug.Log($"[MicroCompact] Compressed {toClear.Count} old tool results");
        }

publicasync Task<string> AutoCompactAsync(List<MessageParam> messages)
        {
// 1. 保存完整记录到磁盘
            Directory.CreateDirectory(_transcriptDir);
var timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
var transcriptPath = Path.Combine(_transcriptDir, $"transcript_{timestamp}.jsonl");

var lines = messages.Select(m => JsonSerializer.Serialize(m));
await File.WriteAllLinesAsync(transcriptPath, lines);
            UnityEngine.Debug.Log($"[AutoCompact] Transcript saved: {transcriptPath}");

// 2. 让 LLM 总结对话
var conversationText = JsonSerializer.Serialize(messages);
if (conversationText.Length > 80000)
                conversationText = conversationText.Substring(0, 80000);

var summaryResponse = await _client.Messages.Create(new MessageCreateParams
            {
                Model = _model,
                Messages = new List<MessageParam>
                {
new MessageParam
                    {
                        Role = Role.User,
                        Content = "Summarize this conversation for continuity. Include: " +
"1) What was accomplished, 2) Current state, 3) Key decisions made. " +
"Be concise but preserve critical details.\n\n" + conversationText
                    }
                },
                MaxTokens = 2000
            });

var summary = string.Join("", summaryResponse.Content
                .Where(c => c.TryPickText(out _))
                .Select(c => { c.TryPickText(outvar t); return t!.Text; }));

// 3. 替换所有消息为压缩摘要
            messages.Clear();
            _toolResultTracker.Clear();

            messages.Add(new MessageParam
            {
                Role = Role.User,
                Content = $"[Conversation compressed. Transcript: {transcriptPath}]\n\n{summary}"
            });
            messages.Add(new MessageParam
            {
                Role = Role.Assistant,
                Content = "Understood. I have the context from the summary. Continuing."
            });

// 4. 清除 TodoManager 的任务列表 - 这是关键的记忆清除
            _todoManager.Clear();
            UnityEngine.Debug.Log("[AutoCompact] TodoManager cleared - memory reset");

// 5. 触发压缩完成事件
            OnCompactCompleted?.Invoke(transcriptPath, summary);

return summary;
        }

publicasync Task<string> ManualCompactAsync(List<MessageParam> messages, string focus = "")
        {
            UnityEngine.Debug.Log($"[ManualCompact] Triggered{(string.IsNullOrEmpty(focus) ? "" : $" with focus: {focus}")}");
returnawait AutoCompactAsync(messages);
        }

publicboolShouldAutoCompact(List<MessageParam> messages)
        {
var tokens = EstimateTokens(messages);
return tokens > TOKEN_THRESHOLD;
        }

publicvoidTrackToolResult(int msgIdx, List<(string toolUseId, string toolName)> toolInfos)
        {
            _toolResultTracker.Add((msgIdx, toolInfos));
        }

publicint TrackedResultCount => _toolResultTracker.Count;

publicvoidClearTrackers()
        {
            _toolResultTracker.Clear();
        }

publicstring[] GetTranscripts()
        {
if (!Directory.Exists(_transcriptDir))
return Array.Empty<string>();

return Directory.GetFiles(_transcriptDir, "transcript_*.jsonl")
                .OrderByDescending(f => f)
                .ToArray();
        }

publicintCleanupOldTranscripts(int keepCount = 10)
        {
var transcripts = GetTranscripts();
if (transcripts.Length <= keepCount)
return0;

var toDelete = transcripts.Skip(keepCount).ToArray();
foreach (varfilein toDelete)
            {
try
                {
                    File.Delete(file);
                }
catch (Exception ex)
                {
                    UnityEngine.Debug.LogWarning($"Failed to delete transcript {file}: {ex.Message}");
                }
            }

            UnityEngine.Debug.Log($"[CleanupTranscripts] Deleted {toDelete.Length} old transcripts");
return toDelete.Length;
        }

#region v6 持久化任务系统

privateintGetMaxTaskId()
        {
var files = Directory.GetFiles(_tasksDir, "task_*.json");
if (files.Length == 0)
return0;

return files
                .Select(f =>
                {
var fileName = Path.GetFileNameWithoutExtension(f);
var parts = fileName.Split('_');
return parts.Length >= 2 && int.TryParse(parts[1], outvar id) ? id : 0;
                })
                .DefaultIfEmpty(0)
                .Max();
        }

private Dictionary<string, JsonElement> LoadTask(int taskId)
        {
var path = Path.Combine(_tasksDir, $"task_{taskId}.json");
if (!File.Exists(path))
thrownew InvalidOperationException($"Task {taskId} not found");

var json = File.ReadAllText(path);
return JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(json);
        }

privatevoidSaveTask(Dictionary<string, JsonElement> task)
        {
var taskId = task["id"].GetInt32();
var path = Path.Combine(_tasksDir, $"task_{taskId}.json");
var json = JsonSerializer.Serialize(task, new JsonSerializerOptions { WriteIndented = true });
            File.WriteAllText(path, json);
        }

publicstringCreateTask(string subject, string description = "", int? sessionId = null)
        {
var task = new Dictionary<string, JsonElement>
            {
                ["id"] = SerializeToElement(_nextTaskId),
                ["subject"] = SerializeToElement(subject),
                ["description"] = SerializeToElement(description),
                ["status"] = SerializeToElement("pending"),
                ["blockedBy"] = SerializeToElement(new List<int>()),
                ["blocks"] = SerializeToElement(new List<int>()),
                ["owner"] = SerializeToElement(""),
                ["sessionId"] = SerializeToElement(sessionId ?? 0),
                ["createdAt"] = SerializeToElement(DateTimeOffset.UtcNow.ToUnixTimeSeconds())
            };

            SaveTask(task);
            UnityEngine.Debug.Log($"[TaskCreate] #{_nextTaskId}: {subject} (Session: {sessionId ?? 0})");
            OnTaskCreated?.Invoke(_nextTaskId, subject);

            _nextTaskId++;

return JsonSerializer.Serialize(task, new JsonSerializerOptions { WriteIndented = true });
        }

publicstringUpdateTask(int taskId, string status = null, List<int> addBlockedBy = null, List<int> addBlocks = null)
        {
var task = LoadTask(taskId);

// 更新状态
if (!string.IsNullOrEmpty(status))
            {
if (status != "pending" && status != "in_progress" && status != "completed")
thrownew InvalidOperationException($"Invalid status: {status}");

                task["status"] = SerializeToElement(status);
                UnityEngine.Debug.Log($"[TaskUpdate] #{taskId} -> {status}");

// 如果任务完成，清除依赖关系
if (status == "completed")
                    ClearDependency(taskId);

                OnTaskUpdated?.Invoke(taskId, status);
            }

// 添加 blockedBy 依赖
if (addBlockedBy != null && addBlockedBy.Count > 0)
            {
var current = GetIntList(task, "blockedBy");
                current.AddRange(addBlockedBy);
                task["blockedBy"] = SerializeToElement(current.Distinct().ToList());
            }

// 添加 blocks 依赖
if (addBlocks != null && addBlocks.Count > 0)
            {
var current = GetIntList(task, "blocks");
                current.AddRange(addBlocks);
                task["blocks"] = SerializeToElement(current.Distinct().ToList());

// 反向更新：将当前任务添加到被阻塞任务的 blockedBy 列表
foreach (var blockedId in addBlocks)
                {
try
                    {
var blocked = LoadTask(blockedId);
var blockedBy = GetIntList(blocked, "blockedBy");
if (!blockedBy.Contains(taskId))
                        {
                            blockedBy.Add(taskId);
                            blocked["blockedBy"] = SerializeToElement(blockedBy);
                            SaveTask(blocked);
                        }
                    }
catch (Exception ex)
                    {
                        UnityEngine.Debug.LogWarning($"Failed to update blocked task {blockedId}: {ex.Message}");
                    }
                }
            }

            task["updatedAt"] = SerializeToElement(DateTimeOffset.UtcNow.ToUnixTimeSeconds());
            SaveTask(task);

return JsonSerializer.Serialize(task, new JsonSerializerOptions { WriteIndented = true });
        }

privatevoidClearDependency(int completedId)
        {
var files = Directory.GetFiles(_tasksDir, "task_*.json");
foreach (varfilein files)
            {
try
                {
var json = File.ReadAllText(file);
var task = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(json);
var blockedBy = GetIntList(task, "blockedBy");

if (blockedBy.Remove(completedId))
                    {
                        task["blockedBy"] = SerializeToElement(blockedBy);
                        SaveTask(task);
                        UnityEngine.Debug.Log($"[ClearDependency] Removed #{completedId} from task #{task["id"].GetInt32()}");
                    }
                }
catch (Exception ex)
                {
                    UnityEngine.Debug.LogWarning($"Failed to process task file {file}: {ex.Message}");
                }
            }
        }

publicstringGetTask(int taskId)
        {
var task = LoadTask(taskId);
return JsonSerializer.Serialize(task, new JsonSerializerOptions { WriteIndented = true });
        }

publicstringListAllTasks(int? sessionId = null)
        {
var files = Directory.GetFiles(_tasksDir, "task_*.json").OrderBy(f => f).ToArray();
if (files.Length == 0)
return"No tasks.";

var lines = new List<string>();
foreach (varfilein files)
            {
try
                {
var json = File.ReadAllText(file);
var task = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(json);

// 如果指定了会话 ID，则过滤任务
if (sessionId.HasValue)
                    {
var taskSessionId = task.TryGetValue("sessionId", outvar sid) ? sid.GetInt32() : 0;
if (taskSessionId != sessionId.Value)
continue;
                    }

var taskId = task["id"].GetInt32();
var subject = task["subject"].GetString();
var status = task["status"].GetString();
var blockedBy = GetIntList(task, "blockedBy");

var marker = status switch
                    {
"pending" => "[ ]",
"in_progress" => "[>]",
"completed" => "[x]",
                        _ => "[?]"
                    };

var blockedInfo = blockedBy.Count > 0
                        ? $" (blocked by: [{string.Join(", ", blockedBy)}])"
                        : "";

                    lines.Add($"{marker} #{taskId}: {subject}{blockedInfo}");
                }
catch (Exception ex)
                {
                    UnityEngine.Debug.LogWarning($"Failed to read task file {file}: {ex.Message}");
                }
            }

return lines.Count > 0 ? string.Join("\n", lines) : "No tasks.";
        }

privatestaticList<int> GetIntList(Dictionary<string, JsonElement> dict, string key)
        {
if (!dict.TryGetValue(key, outvar element))
returnnew List<int>();

if (element.ValueKind == JsonValueKind.Array)
            {
return element.EnumerateArray()
                    .Where(e => e.ValueKind == JsonValueKind.Number)
                    .Select(e => e.GetInt32())
                    .ToList();
            }

returnnew List<int>();
        }

publicvoidDeleteTask(int taskId)
        {
var path = Path.Combine(_tasksDir, $"task_{taskId}.json");
if (File.Exists(path))
            {
                File.Delete(path);
                UnityEngine.Debug.Log($"[TaskDelete] Deleted task #{taskId}");
            }
        }

publicintCleanupCompletedTasks()
        {
var files = Directory.GetFiles(_tasksDir, "task_*.json");
var deletedCount = 0;

foreach (varfilein files)
            {
try
                {
var json = File.ReadAllText(file);
var task = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(json);
if (task["status"].GetString() == "completed")
                    {
                        File.Delete(file);
                        deletedCount++;
                    }
                }
catch (Exception ex)
                {
                    UnityEngine.Debug.LogWarning($"Failed to process task file {file}: {ex.Message}");
                }
            }

if (deletedCount > 0)
                UnityEngine.Debug.Log($"[CleanupTasks] Deleted {deletedCount} completed tasks");

return deletedCount;
        }

publicstringGetTaskStats()
        {
var files = Directory.GetFiles(_tasksDir, "task_*.json");
if (files.Length == 0)
return"No tasks.";

var pending = 0;
var inProgress = 0;
var completed = 0;

foreach (varfilein files)
            {
try
                {
var json = File.ReadAllText(file);
var task = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(json);
var status = task["status"].GetString();

switch (status)
                    {
case"pending": pending++; break;
case"in_progress": inProgress++; break;
case"completed": completed++; break;
                    }
                }
catch { }
            }

return$"Tasks: {files.Length} total | {pending} pending | {inProgress} in progress | {completed} completed";
        }

#endregion
    }
}

Session Manager

有了任务后，这里我们添加会话管理，这样可以处理多个会话功能：

SessionManager.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using Anthropic.Models.Messages;

namespaceClaudeCodeForUnity
{
publicclassSessionManager
    {
privatereadonlystring _sessionsDir;
privateint _nextSessionId;
private Session _currentSession;

publicevent Action<int, string> OnSessionCreated;

publicevent Action<int, string> OnSessionSwitched;

publicevent Action<int> OnSessionUpdated;

publicevent Action<int, int, string> OnTaskCreated;

publicevent Action<int, int, string> OnTaskUpdated;

publicSessionManager(string workDir)
        {
            _sessionsDir = Path.Combine(workDir, ".sessions");

            Directory.CreateDirectory(_sessionsDir);

            _nextSessionId = GetMaxSessionId() + 1;

// 加载或创建默认会话
var existingSessions = GetAllSessions();
if (existingSessions.Count > 0)
            {
// 加载最近使用的会话
                _currentSession = existingSessions.OrderByDescending(s => s.UpdatedAt).First();
                UnityEngine.Debug.Log($"[SessionManager] Loaded session #{_currentSession.Id}: {_currentSession.Name}");
            }
else
            {
// 创建默认会话
                _currentSession = CreateSessionInternal("Default Session");
                UnityEngine.Debug.Log($"[SessionManager] Created default session #{_currentSession.Id}");
            }
        }

public Session CurrentSession => _currentSession;

public Session CreateSession(string name = null)
        {
if (string.IsNullOrWhiteSpace(name))
                name = $"Session {DateTime.Now:yyyy-MM-dd HH:mm}";

var session = CreateSessionInternal(name);
            OnSessionCreated?.Invoke(session.Id, session.Name);
return session;
        }

private Session CreateSessionInternal(string name)
        {
var session = new Session
            {
                Id = _nextSessionId++,
                Name = name,
                CreatedAt = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
                UpdatedAt = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
            };

// 创建会话目录
var sessionDir = GetSessionDirectory(session.Id);
            Directory.CreateDirectory(sessionDir);

// 保存会话元数据
            SaveSession(session);

// 初始化空任务列表
var tasksPath = GetTasksPath(session.Id);
            File.WriteAllText(tasksPath, "[]");

// 初始化空历史文件
var historyPath = GetHistoryPath(session.Id);
            File.WriteAllText(historyPath, "");

            UnityEngine.Debug.Log($"[SessionManager] Session directory created: {sessionDir}");

return session;
        }

publicboolSwitchToSession(int sessionId)
        {
var session = LoadSession(sessionId);
if (session == null)
returnfalse;

            _currentSession = session;
            UnityEngine.Debug.Log($"[SessionManager] Switched to session #{sessionId}: {session.Name}");
            OnSessionSwitched?.Invoke(sessionId, session.Name);
returntrue;
        }

publicvoidRenameCurrentSession(string newName)
        {
if (_currentSession == null) return;

            _currentSession.Name = newName;
            _currentSession.UpdatedAt = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
            SaveSession(_currentSession);
            OnSessionUpdated?.Invoke(_currentSession.Id);
        }

publicboolDeleteSession(int sessionId)
        {
if (_currentSession != null && _currentSession.Id == sessionId)
            {
                UnityEngine.Debug.LogWarning($"[SessionManager] Cannot delete current session #{sessionId}");
returnfalse;
            }

var sessionDir = GetSessionDirectory(sessionId);

try
            {
// 删除整个会话目录（包含所有文件）
if (Directory.Exists(sessionDir))
                {
                    Directory.Delete(sessionDir, true); // recursive = true
                    UnityEngine.Debug.Log($"[SessionManager] Deleted session directory: {sessionDir}");
                }

returntrue;
            }
catch (Exception ex)
            {
                UnityEngine.Debug.LogError($"[SessionManager] Failed to delete session #{sessionId}: {ex.Message}");
returnfalse;
            }
        }

publicvoidSaveConversationHistory(List<MessageParam> messages)
        {
if (_currentSession == null) return;

var historyPath = GetHistoryPath(_currentSession.Id);
var lines = messages.Select(m => JsonSerializer.Serialize(m));
            File.WriteAllLines(historyPath, lines);

            _currentSession.UpdatedAt = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
            SaveSession(_currentSession);
        }

public List<MessageParam> LoadConversationHistory()
        {
if (_currentSession == null)
returnnew List<MessageParam>();

var historyPath = GetHistoryPath(_currentSession.Id);
if (!File.Exists(historyPath))
returnnew List<MessageParam>();

try
            {
var lines = File.ReadAllLines(historyPath);
return lines
                    .Where(line => !string.IsNullOrWhiteSpace(line))
                    .Select(line => JsonSerializer.Deserialize<MessageParam>(line))
                    .ToList();
            }
catch (Exception ex)
            {
                UnityEngine.Debug.LogError($"[SessionManager] Failed to load conversation history: {ex.Message}");
returnnew List<MessageParam>();
            }
        }

public List<Session> GetAllSessions()
        {
var sessions = new List<Session>();
var sessionDirs = Directory.GetDirectories(_sessionsDir, "session_*");

foreach (var sessionDir in sessionDirs)
            {
try
                {
var sessionFile = Path.Combine(sessionDir, "session.json");
if (File.Exists(sessionFile))
                    {
var json = File.ReadAllText(sessionFile);
var session = JsonSerializer.Deserialize<Session>(json);
if (session != null)
                            sessions.Add(session);
                    }
                }
catch (Exception ex)
                {
                    UnityEngine.Debug.LogWarning($"[SessionManager] Failed to load session from {sessionDir}: {ex.Message}");
                }
            }

return sessions.OrderByDescending(s => s.UpdatedAt).ToList();
        }

publicstringGetCurrentSessionTaskSummary()
        {
if (_currentSession == null)
return"No active session";

var tasks = LoadCurrentSessionTasks();
return$"Session: {_currentSession.Name} | Tasks: {tasks.Count}";
        }

#region 私有方法

privateintGetMaxSessionId()
        {
var sessionDirs = Directory.GetDirectories(_sessionsDir, "session_*");
if (sessionDirs.Length == 0)
return0;

return sessionDirs
                .Select(dir =>
                {
var dirName = Path.GetFileName(dir);
var parts = dirName.Split('_');
return parts.Length >= 2 && int.TryParse(parts[1], outvar id) ? id : 0;
                })
                .DefaultIfEmpty(0)
                .Max();
        }

privatestringGetSessionDirectory(int sessionId)
        {
return Path.Combine(_sessionsDir, $"session_{sessionId}");
        }

privatestringGetSessionPath(int sessionId)
        {
return Path.Combine(GetSessionDirectory(sessionId), "session.json");
        }

privatestringGetHistoryPath(int sessionId)
        {
return Path.Combine(GetSessionDirectory(sessionId), "history.jsonl");
        }

privatestringGetTasksPath(int sessionId)
        {
return Path.Combine(GetSessionDirectory(sessionId), "tasks.json");
        }

privatevoidSaveSession(Session session)
        {
// 确保会话目录存在
var sessionDir = GetSessionDirectory(session.Id);
            Directory.CreateDirectory(sessionDir);

// 保存会话元数据
var path = GetSessionPath(session.Id);
var json = JsonSerializer.Serialize(session, new JsonSerializerOptions { WriteIndented = true });
            File.WriteAllText(path, json);
        }

private Session LoadSession(int sessionId)
        {
var path = GetSessionPath(sessionId);
if (!File.Exists(path))
returnnull;

try
            {
var json = File.ReadAllText(path);
return JsonSerializer.Deserialize<Session>(json);
            }
catch (Exception ex)
            {
                UnityEngine.Debug.LogError($"[SessionManager] Failed to load session #{sessionId}: {ex.Message}");
returnnull;
            }
        }

#region 任务管理

private List<SessionTask> LoadCurrentSessionTasks()
        {
if (_currentSession == null)
returnnew List<SessionTask>();

var tasksPath = GetTasksPath(_currentSession.Id);
if (!File.Exists(tasksPath))
returnnew List<SessionTask>();

try
            {
var json = File.ReadAllText(tasksPath);
return JsonSerializer.Deserialize<List<SessionTask>>(json) ?? new List<SessionTask>();
            }
catch (Exception ex)
            {
                UnityEngine.Debug.LogError($"[SessionManager] Failed to load tasks: {ex.Message}");
returnnew List<SessionTask>();
            }
        }

privatevoidSaveCurrentSessionTasks(List<SessionTask> tasks)
        {
if (_currentSession == null) return;

var tasksPath = GetTasksPath(_currentSession.Id);
var json = JsonSerializer.Serialize(tasks, new JsonSerializerOptions { WriteIndented = true });
            File.WriteAllText(tasksPath, json);

            _currentSession.UpdatedAt = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
            SaveSession(_currentSession);
        }

public SessionTask CreateTask(string subject, string description = "")
        {
if (_currentSession == null)
thrownew InvalidOperationException("No active session");

var tasks = LoadCurrentSessionTasks();
var nextId = tasks.Count > 0 ? tasks.Max(t => t.Id) + 1 : 1;

var task = new SessionTask
            {
                Id = nextId,
                Subject = subject,
                Description = description,
                Status = "pending",
                BlockedBy = new List<int>(),
                Blocks = new List<int>(),
                CreatedAt = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
            };

            tasks.Add(task);
            SaveCurrentSessionTasks(tasks);

            UnityEngine.Debug.Log($"[SessionManager] Task #{nextId} created in session #{_currentSession.Id}: {subject}");
            OnTaskCreated?.Invoke(_currentSession.Id, nextId, subject);

return task;
        }

public SessionTask UpdateTask(int taskId, string status = null, List<int> addBlockedBy = null, List<int> addBlocks = null)
        {
if (_currentSession == null)
thrownew InvalidOperationException("No active session");

var tasks = LoadCurrentSessionTasks();
var task = tasks.FirstOrDefault(t => t.Id == taskId);
if (task == null)
thrownew InvalidOperationException($"Task #{taskId} not found in current session");

// 更新状态
if (!string.IsNullOrEmpty(status))
            {
if (status != "pending" && status != "in_progress" && status != "completed")
thrownew InvalidOperationException($"Invalid status: {status}");

                task.Status = status;
                UnityEngine.Debug.Log($"[SessionManager] Task #{taskId} -> {status}");

// 如果任务完成，清除依赖
if (status == "completed")
                {
foreach (var t in tasks)
                    {
                        t.BlockedBy.Remove(taskId);
                    }
                }

                OnTaskUpdated?.Invoke(_currentSession.Id, taskId, status);
            }

// 添加 blockedBy 依赖
if (addBlockedBy != null && addBlockedBy.Count > 0)
            {
foreach (var id in addBlockedBy)
                {
if (!task.BlockedBy.Contains(id))
                        task.BlockedBy.Add(id);
                }
            }

// 添加 blocks 依赖
if (addBlocks != null && addBlocks.Count > 0)
            {
foreach (var id in addBlocks)
                {
if (!task.Blocks.Contains(id))
                        task.Blocks.Add(id);

// 反向更新
var blockedTask = tasks.FirstOrDefault(t => t.Id == id);
if (blockedTask != null && !blockedTask.BlockedBy.Contains(taskId))
                    {
                        blockedTask.BlockedBy.Add(taskId);
                    }
                }
            }

            task.UpdatedAt = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
            SaveCurrentSessionTasks(tasks);

return task;
        }

public SessionTask GetTask(int taskId)
        {
if (_currentSession == null)
thrownew InvalidOperationException("No active session");

var tasks = LoadCurrentSessionTasks();
return tasks.FirstOrDefault(t => t.Id == taskId);
        }

public List<SessionTask> ListTasks()
        {
return LoadCurrentSessionTasks();
        }

publicboolDeleteTask(int taskId)
        {
if (_currentSession == null)
returnfalse;

var tasks = LoadCurrentSessionTasks();
var task = tasks.FirstOrDefault(t => t.Id == taskId);
if (task == null)
returnfalse;

            tasks.Remove(task);
            SaveCurrentSessionTasks(tasks);

            UnityEngine.Debug.Log($"[SessionManager] Task #{taskId} deleted");
returntrue;
        }

publicstringGetTaskStats()
        {
var tasks = LoadCurrentSessionTasks();
if (tasks.Count == 0)
return"No tasks";

var pending = tasks.Count(t => t.Status == "pending");
var inProgress = tasks.Count(t => t.Status == "in_progress");
var completed = tasks.Count(t => t.Status == "completed");

return$"Tasks: {tasks.Count} total | {pending} pending | {inProgress} in progress | {completed} completed";
        }

#endregion

#endregion
    }

publicclassSession
    {
publicint Id { get; set; }

publicstring Name { get; set; }

publiclong CreatedAt { get; set; }

publiclong UpdatedAt { get; set; }

publicstringGetFormattedCreatedAt()
        {
return DateTimeOffset.FromUnixTimeSeconds(CreatedAt).ToLocalTime().ToString("yyyy-MM-dd HH:mm");
        }

publicstringGetFormattedUpdatedAt()
        {
return DateTimeOffset.FromUnixTimeSeconds(UpdatedAt).ToLocalTime().ToString("yyyy-MM-dd HH:mm");
        }
    }

publicclassSessionTask
    {
publicint Id { get; set; }

publicstring Subject { get; set; }

publicstring Description { get; set; }

publicstring Status { get; set; }

public List<int> BlockedBy { get; set; }

public List<int> Blocks { get; set; }

publiclong CreatedAt { get; set; }

publiclong UpdatedAt { get; set; }
    }
}