\u002F\u002F MCP Resource 示例
{
  "uri": "file:\u002F\u002F\u002Fworkspace\u002FREADME.md",
  "name": "项目文档",
  "mimeType": "text\u002Fmarkdown",
  "description": "项目需求和架构文档"
}

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("code-tools")

@mcp.tool()
async def run_tests(test_file: str) -> str:
    """运行指定的测试文件"""
    result = subprocess.run(['pytest', test_file], capture_output=True)
    return result.stdout.decode()

{
  "name": "code_review",
  "description": "代码审查提示模板",
  "arguments": [
    {
      "name": "language",
      "description": "编程语言",
      "required": true
    }
  ]
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "initialize",
  "params": {
    "protocolVersion": "0.1.0",
    "clientInfo": {
      "name": "Zed",
      "version": "0.158.0"
    }
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "protocolVersion": "0.1.0",
    "serverInfo": {
      "name": "Claude Code",
      "version": "1.0.0"
    },
    "capabilities": {
      "tools": true,
      "resources": true
    }
  }
}

{
  "jsonrpc": "2.0",
  "method": "session\u002Fupdate",
  "params": {
    "sessionId": "session-123",
    "update": {
      "sessionUpdate": "agent_message_chunk",
      "content": {
        "type": "text",
        "text": "正在分析代码..."
      }
    }
  }
}

\u002F\u002F AionUi 项目中的实际代码
\u002F\u002F src\u002Fagent\u002Facp\u002FAcpConnection.ts

async connect(backend: AcpBackend, cliPath?: string, workingDir?: string) {
  const command = cliPath || this.getDefaultCliPath(backend);

  \u002F\u002F 使用 spawn 启动 Agent 子进程
  this.agentProcess = spawn(command, [], {
    cwd: workingDir,
    env: process.env,
  });

  \u002F\u002F 监听 stdout（Agent 的输出）
  this.agentProcess.stdout.on('data', this.handleStdout.bind(this));

  \u002F\u002F 监听 stderr（Agent 的日志）
  this.agentProcess.stderr.on('data', this.handleStderr.bind(this));

  \u002F\u002F 初始化协议
  await this.initialize();
}

private async initialize(): Promise<AcpResponse> {
  return await this.sendRequest('initialize', {
    protocolVersion: '0.1.0',
    clientInfo: {
      name: 'AionUi',
      version: '1.0.0',
    },
  });
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "protocolVersion": "0.1.0",
    "serverInfo": {
      "name": "Claude Code",
      "version": "1.0.128"
    },
    "capabilities": {
      "tools": true,
      "resources": true,
      "streaming": false
    }
  }
}

\u002F\u002F AionUi 项目中的类型定义
\u002F\u002F src\u002Ftypes\u002FacpTypes.ts

export type AcpSessionUpdate =
  | AgentMessageChunkUpdate \u002F\u002F Agent 消息块
  | AgentThoughtChunkUpdate \u002F\u002F Agent 思考过程
  | ToolCallUpdate \u002F\u002F 工具调用
  | ToolCallUpdateStatus \u002F\u002F 工具状态更新
  | PlanUpdate \u002F\u002F 任务计划
  | AvailableCommandsUpdate \u002F\u002F 可用命令列表
  | UserMessageChunkUpdate; \u002F\u002F 用户消息块

{
  "method": "session\u002Fupdate",
  "params": {
    "sessionId": "sess-123",
    "update": {
      "sessionUpdate": "agent_message_chunk",
      "content": {
        "type": "text",
        "text": "我已经分析了你的代码，发现了以下问题..."
      }
    }
  }
}

{
  "method": "session\u002Fupdate",
  "params": {
    "sessionId": "sess-123",
    "update": {
      "sessionUpdate": "agent_thought_chunk",
      "content": {
        "type": "text",
        "text": "首先，我需要检查 package.json 中的依赖版本..."
      }
    }
  }
}

interface ToolCallUpdate {
  sessionUpdate: 'tool_call';
  toolCallId: string; \u002F\u002F 工具调用唯一 ID
  status: 'pending' | 'in_progress' | 'completed' | 'failed';
  title: string; \u002F\u002F 操作描述
  kind: 'read' | 'edit' | 'execute'; \u002F\u002F 操作类型
  rawInput?: any; \u002F\u002F 原始输入参数
  content?: Array<{
    type: 'content' | 'diff';
    \u002F\u002F ... 内容详情
  }>;
  locations?: Array<{
    path: string; \u002F\u002F 受影响的文件路径
  }>;
}

{
  "method": "session\u002Fupdate",
  "params": {
    "sessionId": "sess-123",
    "update": {
      "sessionUpdate": "tool_call",
      "toolCallId": "tool-001",
      "status": "pending",
      "title": "读取 src\u002Findex.ts",
      "kind": "read",
      "locations": [{ "path": "\u002Fworkspace\u002Fsrc\u002Findex.ts" }]
    }
  }
}

{
  "method": "session\u002Fupdate",
  "params": {
    "sessionId": "sess-123",
    "update": {
      "sessionUpdate": "tool_call",
      "toolCallId": "tool-002",
      "status": "in_progress",
      "title": "修复 TypeScript 类型错误",
      "kind": "edit",
      "content": [
        {
          "type": "diff",
          "diff": "--- a\u002Fsrc\u002Findex.ts\
+++ b\u002Fsrc\u002Findex.ts\
@@ -10,7 +10,7 @@\
-function add(a, b) {\
+function add(a: number, b: number): number {\
   return a + b;\
 }"
        }
      ],
      "locations": [{ "path": "\u002Fworkspace\u002Fsrc\u002Findex.ts" }]
    }
  }
}

{
  "method": "session\u002Fupdate",
  "params": {
    "sessionId": "sess-123",
    "update": {
      "sessionUpdate": "plan",
      "entries": [
        {
          "content": "分析现有代码结构",
          "status": "completed"
        },
        {
          "content": "识别类型错误位置",
          "status": "in_progress"
        },
        {
          "content": "修复类型定义",
          "status": "pending",
          "priority": "high"
        },
        {
          "content": "运行 TypeScript 编译检查",
          "status": "pending"
        }
      ]
    }
  }
}

interface AcpPermissionRequest {
  sessionId: string;
  options: Array<{
    optionId: string;
    name: string;
    kind: 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
  }>;
  toolCall: {
    toolCallId: string;
    title: string;
    kind: 'read' | 'edit' | 'execute';
    content?: Array<any>;
    locations?: Array<{ path: string }>;
  };
}

{
  "method": "session\u002Frequest_permission",
  "params": {
    "sessionId": "sess-123",
    "options": [
      {
        "optionId": "allow_once",
        "name": "仅此一次允许",
        "kind": "allow_once"
      },
      {
        "optionId": "allow_always",
        "name": "始终允许对此文件的写入",
        "kind": "allow_always"
      },
      {
        "optionId": "reject",
        "name": "拒绝",
        "kind": "reject_once"
      }
    ],
    "toolCall": {
      "toolCallId": "tool-003",
      "title": "写入文件 src\u002Fconfig.ts",
      "kind": "edit",
      "locations": [{ "path": "\u002Fworkspace\u002Fsrc\u002Fconfig.ts" }],
      "content": [
        {
          "type": "diff",
          "diff": "... (修改内容) ..."
        }
      ]
    }
  }
}

\u002F\u002F src\u002Frenderer\u002Fmessages\u002Facp\u002FMessageAcpPermission.tsx

const MessageAcpPermission: React.FC<Props> = ({ message }) => {
  const handleConfirm = async (optionId: string) => {
    \u002F\u002F 调用 IPC Bridge 确认权限
    await ipcBridge.acpConversation.confirmMessage.invoke({
      confirmKey: message.confirmKey,
      msg_id: message.msg_id,
      conversation_id: message.conversation_id,
      callId: message.toolCall.toolCallId,
    });
  };

  return (
    <div className="permission-dialog">
      <h3>{message.toolCall.title}<\u002Fh3>
      <div className="options">
        {message.options.map(option => (
          <button key={option.optionId} onClick={() => handleConfirm(option.optionId)}>
            {option.name}
          <\u002Fbutton>
        ))}
      <\u002Fdiv>
    <\u002Fdiv>
  );
};

\u002F\u002F src\u002Fagent\u002Facp\u002FAcpConnection.ts (605 行)

export class AcpConnection {
  private agentProcess: ChildProcess | null = null;
  private pendingRequests: Map<number, PendingRequest> = new Map();
  private requestIdCounter = 0;

  \u002F\u002F 事件回调
  public onSessionUpdate?: (data: AcpSessionUpdate) => void;
  public onPermissionRequest?: (data: AcpPermissionRequest) => Promise<{ optionId: string }>;
  public onEndTurn?: () => void;
  public onFileOperation?: (operation: any) => void;

  \u002F**
   * 连接到 Agent
   *\u002F
  async connect(backend: AcpBackend, cliPath?: string, workingDir?: string) {
    const command = cliPath || this.getDefaultCliPath(backend);

    \u002F\u002F 启动 Agent 子进程
    this.agentProcess = spawn(command, [], {
      cwd: workingDir,
      env: process.env,
      stdio: ['pipe', 'pipe', 'pipe'], \u002F\u002F stdin, stdout, stderr
    });

    \u002F\u002F 监听输出
    this.agentProcess.stdout.on('data', this.handleStdout.bind(this));
    this.agentProcess.stderr.on('data', this.handleStderr.bind(this));

    \u002F\u002F 初始化协议
    await this.initialize();
  }

  \u002F**
   * 发送 JSON-RPC 请求
   *\u002F
  private async sendRequest(method: string, params: any, timeout = 60000): Promise<AcpResponse> {
    const id = ++this.requestIdCounter;

    const request: AcpRequest = {
      jsonrpc: JSONRPC_VERSION,
      id,
      method,
      params,
    };

    \u002F\u002F 创建 Promise，等待响应
    return new Promise((resolve, reject) => {
      const timer = setTimeout(() => {
        this.pendingRequests.delete(id);
        reject(new Error(`Request ${method} timeout after ${timeout}ms`));
      }, timeout);

      this.pendingRequests.set(id, { resolve, reject, timer });

      \u002F\u002F 写入 Agent 的 stdin
      const message = JSON.stringify(request) + '\
';
      this.agentProcess.stdin.write(message);
    });
  }

  \u002F**
   * 处理 Agent 的输出
   *\u002F
  private handleStdout(data: Buffer) {
    const lines = data
      .toString()
      .split('\
')
      .filter((line) => line.trim());

    for (const line of lines) {
      try {
        const message = JSON.parse(line);

        if ('id' in message && 'result' in message) {
          \u002F\u002F Response: 匹配请求并 resolve
          const pending = this.pendingRequests.get(message.id);
          if (pending) {
            clearTimeout(pending.timer);
            pending.resolve(message);
            this.pendingRequests.delete(message.id);
          }
        } else if ('method' in message) {
          \u002F\u002F Notification: 触发回调
          this.handleNotification(message);
        }
      } catch (error) {
        console.error('Failed to parse message:', line, error);
      }
    }
  }

  \u002F**
   * 处理通知消息
   *\u002F
  private handleNotification(notification: AcpNotification) {
    const { method, params } = notification;

    switch (method) {
      case 'session\u002Fupdate':
        if (this.onSessionUpdate) {
          this.onSessionUpdate(params.update);
        }
        break;

      case 'session\u002Frequest_permission':
        if (this.onPermissionRequest) {
          this.handlePermissionRequest(params);
        }
        break;

      case 'end_turn':
        if (this.onEndTurn) {
          this.onEndTurn();
        }
        break;

      case 'fs\u002Fread_text_file':
        this.handleReadOperation(params);
        break;

      case 'fs\u002Fwrite_text_file':
        this.handleWriteOperation(params);
        break;
    }
  }

  \u002F**
   * 创建新会话
   *\u002F
  async newSession(cwd: string): Promise<AcpResponse> {
    return await this.sendRequest(
      'session\u002Fnew',
      {
        cwd,
        mcpServers: [], \u002F\u002F 可配置 MCP 服务器
      },
      120000
    ); \u002F\u002F 120 秒超时
  }

  \u002F**
   * 发送用户消息
   *\u002F
  async sendPrompt(prompt: string): Promise<AcpResponse> {
    return await this.sendRequest(
      'session\u002Fprompt',
      {
        prompt,
      },
      120000
    );
  }

  \u002F**
   * 断开连接
   *\u002F
  async disconnect() {
    if (this.agentProcess) {
      this.agentProcess.kill();
      this.agentProcess = null;
    }
    this.pendingRequests.clear();
  }
}

\u002F\u002F src\u002Fagent\u002Facp\u002Findex.ts (607 行)

export class AcpAgent {
  private connection: AcpConnection;
  private sessionId: string | null = null;
  private onStreamEvent: (event: any) => void;

  constructor(options: { id: string; backend: AcpBackend; cliPath?: string; workingDir?: string; onStreamEvent: (event: any) => void }) {
    this.onStreamEvent = options.onStreamEvent;

    \u002F\u002F 创建连接
    this.connection = new AcpConnection();

    \u002F\u002F 注册回调
    this.connection.onSessionUpdate = this.handleSessionUpdate.bind(this);
    this.connection.onPermissionRequest = this.handlePermissionRequest.bind(this);
    this.connection.onEndTurn = this.handleEndTurn.bind(this);
    this.connection.onFileOperation = this.handleFileOperation.bind(this);
  }

  \u002F**
   * 启动 Agent
   *\u002F
  async start() {
    await this.connection.connect(this.backend, this.cliPath, this.workingDir);

    \u002F\u002F 创建会话
    const response = await this.connection.newSession(this.workingDir);
    this.sessionId = response.result.sessionId;
  }

  \u002F**
   * 发送消息
   *\u002F
  async sendMessage(data: { content: string; files?: string[]; msg_id?: string }): Promise<AcpResult> {
    try {
      await this.connection.sendPrompt(data.content);
      return { success: true };
    } catch (error) {
      return { success: false, error: error.message };
    }
  }

  \u002F**
   * 处理会话更新
   *\u002F
  private handleSessionUpdate(update: AcpSessionUpdate) {
    \u002F\u002F 使用适配器转换为统一格式
    const event = AcpAdapter.convertUpdate(update);

    \u002F\u002F 触发流事件
    this.onStreamEvent(event);
  }

  \u002F**
   * 处理权限请求
   *\u002F
  private async handlePermissionRequest(params: AcpPermissionRequest): Promise<{ optionId: string }> {
    \u002F\u002F 创建权限消息，显示给用户
    const permissionMessage = {
      role: 'permission_request',
      options: params.options,
      toolCall: params.toolCall,
      confirmKey: generateConfirmKey(),
    };

    this.onStreamEvent(permissionMessage);

    \u002F\u002F 等待用户响应（通过 confirmMessage 方法）
    return new Promise((resolve) => {
      this.pendingPermissionResolve = resolve;
    });
  }

  \u002F**
   * 确认权限（用户选择后调用）
   *\u002F
  async confirmMessage(data: { confirmKey: string; msg_id: string; callId: string }) {
    \u002F\u002F 将用户选择的 optionId 返回给 Agent
    if (this.pendingPermissionResolve) {
      this.pendingPermissionResolve({ optionId: data.confirmKey });
      this.pendingPermissionResolve = null;
    }
  }
}

\u002F\u002F src\u002Frenderer\u002Fpages\u002Fconversation\u002Facp\u002FAcpChat.tsx

const AcpChat: React.FC<{
  conversation_id: string;
  workspace?: string;
  backend: AcpBackend;
}> = ({ conversation_id, workspace, backend }) => {
  return (
    <ConversationProvider value={{
      conversationId: conversation_id,
      workspace,
      type: 'acp',
    }}>
      {\u002F* 消息列表 *\u002F}
      <MessageList \u002F>

      {\u002F* 输入框 *\u002F}
      <AcpSendBox conversation_id={conversation_id} backend={backend} \u002F>
    <\u002FConversationProvider>
  );
};

\u002F\u002F src\u002Frenderer\u002Fmessages\u002Facp\u002FMessageAcpToolCall.tsx

const MessageAcpToolCall: React.FC<{ toolCall: ToolCallUpdate }> = ({ toolCall }) => {
  return (
    <div className="tool-call">
      {\u002F* 工具图标 *\u002F}
      <div className="tool-icon">
        {toolCall.kind === 'read' && <FileIcon \u002F>}
        {toolCall.kind === 'edit' && <EditIcon \u002F>}
        {toolCall.kind === 'execute' && <TerminalIcon \u002F>}
      <\u002Fdiv>

      {\u002F* 工具标题 *\u002F}
      <div className="tool-title">{toolCall.title}<\u002Fdiv>

      {\u002F* 状态指示器 *\u002F}
      <div className={`tool-status tool-status-${toolCall.status}`}>
        {toolCall.status === 'pending' && <ClockIcon \u002F>}
        {toolCall.status === 'in_progress' && <SpinnerIcon \u002F>}
        {toolCall.status === 'completed' && <CheckIcon \u002F>}
        {toolCall.status === 'failed' && <XIcon \u002F>}
      <\u002Fdiv>

      {\u002F* 文件路径 *\u002F}
      {toolCall.locations && (
        <div className="tool-locations">
          {toolCall.locations.map(loc => (
            <span key={loc.path}>{loc.path}<\u002Fspan>
          ))}
        <\u002Fdiv>
      )}

      {\u002F* Diff 内容 *\u002F}
      {toolCall.content && toolCall.content[0]?.type === 'diff' && (
        <DiffViewer diff={toolCall.content[0].diff} \u002F>
      )}
    <\u002Fdiv>
  );
};

\u002F\u002F src\u002Fprocess\u002Fbridge\u002FacpConversationBridge.ts

export function initAcpConversationBridge() {
  \u002F\u002F 确认权限
  ipcBridge.acpConversation.confirmMessage.provider(async ({ confirmKey, msg_id, conversation_id, callId }) => {
    const task = WorkerManage.getTaskById(conversation_id) as AcpAgentManager;
    await task.confirmMessage({ confirmKey, msg_id, callId });
    return { success: true };
  });

  \u002F\u002F 检测可用的 Agent
  ipcBridge.acpConversation.getAvailableAgents.provider(async () => {
    const agents = acpDetector.getDetectedAgents();
    return { success: true, data: agents };
  });

  \u002F\u002F 检测 CLI 路径
  ipcBridge.acpConversation.detectCliPath.provider(async ({ backend }) => {
    const agents = acpDetector.getDetectedAgents();
    const agent = agents.find((a) => a.backend === backend);
    return {
      success: !!agent?.cliPath,
      data: { path: agent?.cliPath },
    };
  });
}

\u002F\u002F src\u002Fagent\u002Facp\u002FAcpConnection.ts

async newSession(cwd: string): Promise<AcpResponse> {
  return await this.sendRequest('session\u002Fnew', {
    cwd,
    \u002F\u002F 可以在创建 ACP 会话时配置 MCP 服务器
    mcpServers: [
      {
        name: 'database',
        command: 'node',
        args: ['.\u002Fmcp-servers\u002Fdatabase-server.js'],
      },
      {
        name: 'git',
        command: 'node',
        args: ['.\u002Fmcp-servers\u002Fgit-server.js'],
      },
    ],
  });
}

\u002F\u002F ~\u002F.config\u002Fzed\u002Fsettings.json
{
  "agents": {
    "claude": {
      "command": "claude-code",
      "args": [],
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    },
    "gemini": {
      "command": "gemini-cli",
      "args": ["--model", "gemini-1.5-pro"]
    },
    "codex": {
      "command": "codex",
      "args": ["--api-key", "sk-..."]
    }
  }
}

\u002F\u002F 不要写入 stdout！
console.log('Agent is processing...');

\u002F\u002F 使用 stderr 或文件日志
import fs from 'fs';

const logFile = fs.createWriteStream('\u002Ftmp\u002Fagent.log');

function log(message: string) {
  logFile.write(`[${new Date().toISOString()}] ${message}\
`);
}

log('Agent is processing...');

try {
  await executeToolCall(toolCall);
} catch (error) {
  \u002F\u002F 返回标准错误格式
  return {
    jsonrpc: '2.0',
    id: requestId,
    error: {
      code: -32603,
      message: error.message,
      data: {
        stack: error.stack,
      },
    },
  };
}

const TOOL_CALL_TIMEOUT = 30000; \u002F\u002F 30 秒

async function executeToolCallWithTimeout(toolCall: ToolCall) {
  return Promise.race([executeToolCall(toolCall), new Promise((_, reject) => setTimeout(() => reject(new Error('Tool call timeout')), TOOL_CALL_TIMEOUT))]);
}

async function generateCode(prompt: string) {
  \u002F\u002F 发送进度更新
  sendNotification('session\u002Fupdate', {
    update: {
      sessionUpdate: 'agent_thought_chunk',
      content: { type: 'text', text: '正在分析需求...' },
    },
  });

  \u002F\u002F 生成代码
  const code = await llm.generate(prompt);

  \u002F\u002F 发送代码块
  sendNotification('session\u002Fupdate', {
    update: {
      sessionUpdate: 'agent_message_chunk',
      content: { type: 'text', text: code },
    },
  });
}

\u002F\u002F 定义允许的工作目录
const ALLOWED_WORKSPACE = process.env.WORKSPACE_DIR;

function validateFilePath(path: string): boolean {
  const resolvedPath = path.resolve(path);

  \u002F\u002F 检查路径是否在允许的工作目录内
  if (!resolvedPath.startsWith(ALLOWED_WORKSPACE)) {
    throw new Error('Access denied: path outside workspace');
  }

  \u002F\u002F 检查是否访问敏感文件
  const sensitivePatterns = ['.env', '.git\u002Fconfig', 'id_rsa'];
  if (sensitivePatterns.some((pattern) => resolvedPath.includes(pattern))) {
    throw new Error('Access denied: sensitive file');
  }

  return true;
}

\u002F\u002F 白名单机制
const ALLOWED_COMMANDS = ['npm test', 'npm run lint', 'tsc --noEmit', 'git status'];

function validateCommand(command: string): boolean {
  return ALLOWED_COMMANDS.some((allowed) => command.startsWith(allowed));
}

async function executeCommand(command: string) {
  if (!validateCommand(command)) {
    throw new Error('Command not allowed');
  }

  \u002F\u002F 执行命令
  return execAsync(command, {
    timeout: 30000,
    cwd: WORKSPACE_DIR,
  });
}

async function requestPermission(toolCall: ToolCall): Promise<boolean> {
  \u002F\u002F 发送权限请求
  sendNotification('session\u002Frequest_permission', {
    sessionId: currentSessionId,
    options: [
      { optionId: 'allow_once', name: '仅此一次允许', kind: 'allow_once' },
      { optionId: 'allow_always', name: '始终允许', kind: 'allow_always' },
      { optionId: 'reject', name: '拒绝', kind: 'reject_once' },
    ],
    toolCall,
  });

  \u002F\u002F 等待用户响应
  const response = await waitForPermissionResponse();

  \u002F\u002F 缓存权限决策
  if (response.kind === 'allow_always') {
    permissionCache.set(toolCall.kind, true);
  } else if (response.kind === 'reject_always') {
    permissionCache.set(toolCall.kind, false);
  }

  return response.kind.startsWith('allow');
}

\u002F\u002F 过滤敏感信息
function sanitizeContent(content: string): string {
  \u002F\u002F 移除 API 密钥
  content = content.replace(\u002Fsk-[a-zA-Z0-9]{48}\u002Fg, '***API_KEY***');

  \u002F\u002F 移除密码
  content = content.replace(\u002Fpassword\\s*=\\s*['"][^'"]+['"]\u002Fgi, 'password=***');

  \u002F\u002F 移除 Token
  content = content.replace(\u002FBearer\\s+[a-zA-Z0-9._-]+\u002Fg, 'Bearer ***');

  return content;
}

\u002F\u002F 批量读取文件
async function readMultipleFiles(paths: string[]): Promise<Map<string, string>> {
  const results = new Map();

  await Promise.all(
    paths.map(async (path) => {
      const content = await fs.readFile(path, 'utf-8');
      results.set(path, content);
    })
  );

  return results;
}

\u002F\u002F 只发送变化的内容
let lastContent = '';

function sendDiffUpdate(newContent: string) {
  const diff = computeDiff(lastContent, newContent);

  if (diff) {
    sendNotification('session\u002Fupdate', {
      update: {
        sessionUpdate: 'agent_message_chunk',
        content: { type: 'diff', diff },
      },
    });
  }

  lastContent = newContent;
}

\u002F\u002F 缓存文件内容
const fileCache = new LRU<string, string>({
  max: 100,
  maxAge: 5 * 60 * 1000, \u002F\u002F 5 分钟
});

async function readFileWithCache(path: string): Promise<string> {
  const cached = fileCache.get(path);
  if (cached) return cached;

  const content = await fs.readFile(path, 'utf-8');
  fileCache.set(path, content);

  return content;
}

\u002F\u002F 未来可能支持的内容类型
interface FutureContent {
  type: 'text' | 'image' | 'video' | 'audio' | 'diagram' | '3d-model';
  \u002F\u002F ...
}

\u002F\u002F 示例：Agent 生成架构图
{
  sessionUpdate: 'agent_message_chunk',
  content: {
    type: 'diagram',
    format: 'mermaid',
    data: `
      graph TD
        A[Client] -->|HTTP| B[Server]
        B --> C[Database]
    `
  }
}

\u002F\u002F 未来的会话上下文
interface EnhancedSessionContext {
  \u002F\u002F 项目元数据
  project: {
    name: string;
    language: string[];
    framework: string[];
    dependencies: Record<string, string>;
  };

  \u002F\u002F 代码图谱
  codeGraph: {
    files: FileNode[];
    imports: ImportEdge[];
    exports: ExportEdge[];
  };

  \u002F\u002F 历史操作
  history: Operation[];

  \u002F\u002F 用户偏好
  preferences: {
    codingStyle: string;
    testFramework: string;
    \u002F\u002F ...
  };
}

\u002F\u002F agent-manifest.json
{
  "name": "my-custom-agent",
  "version": "1.0.0",
  "description": "A custom coding agent for Rust projects",
  "author": "Your Name",
  "capabilities": {
    "languages": ["rust", "toml"],
    "frameworks": ["tokio", "actix"],
    "tools": {
      "code_generation": true,
      "refactoring": true,
      "testing": true,
      "debugging": false
    }
  },
  "requirements": {
    "model": "gpt-4",
    "apiKey": "required",
    "minEditorVersion": "0.158.0"
  }
}

\u002F\u002F 未来的跨编辑器配置同步
interface AgentConfig {
  agents: {
    [name: string]: {
      command: string;
      args: string[];
      env: Record<string, string>;
      settings: any;
    };
  };
  preferences: {
    defaultAgent: string;
    autoStart: boolean;
    \u002F\u002F ...
  };
}

\u002F\u002F 同步到云端
await syncConfigToCloud(config);

\u002F\u002F 在另一台设备上
const config = await loadConfigFromCloud();

\u002F\u002F Agent 可以理解调试信息
{
  sessionUpdate: 'debug_analysis',
  breakpoint: {
    file: 'src\u002Findex.ts',
    line: 42,
    variables: {
      user: { id: 123, name: 'Alice' },
      error: new Error('Invalid token')
    }
  },
  suggestion: "错误是因为 token 已过期，建议添加 token 刷新逻辑"
}

# 安装 ACP SDK
npm install @agentclientprotocol\u002Fsdk

# 参考 Zed 的实现
git clone https:\u002F\u002Fgithub.com\u002Fzed-industries\u002Fzed

# 选择你喜欢的语言 SDK
npm install @agentclientprotocol\u002Fsdk       # TypeScript
pip install agent-client-protocol          # Python
cargo add agent-client-protocol            # Rust

# 下载支持 ACP 的编辑器
# Zed
curl https:\u002F\u002Fzed.dev\u002Finstall.sh | sh

# 配置你喜欢的 Agent
zed --config agents.claude.command="claude-code"