@ddlqhd/agent-sdk 0.1.0

package/dist/chunk-Q3SOMX26.js

@@ -0,0 +1,2854 @@
+#!/usr/bin/env node
+import { ToolRegistry, createAgentTool, HookManager, getAllBuiltinTools, getEnvironmentInfo, formatEnvironmentSection } from './chunk-OHXW2YM6.js';
+import { promises, existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { randomUUID } from 'crypto';
+import { homedir } from 'os';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { z } from 'zod';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+var JsonlStorage = class {
+  basePath;
+  constructor(config = {}) {
+    this.basePath = config.basePath || "./sessions";
+  }
+  /**
+   * 获取会话文件路径
+   */
+  getFilePath(sessionId) {
+    const safeId = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return join(this.basePath, `${safeId}.jsonl`);
+  }
+  /**
+   * 获取元数据文件路径
+   */
+  getMetaFilePath(sessionId) {
+    const safeId = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return join(this.basePath, `${safeId}.meta.json`);
+  }
+  /**
+   * 确保目录存在
+   */
+  async ensureDir() {
+    await promises.mkdir(this.basePath, { recursive: true });
+  }
+  /**
+   * 保存消息（追加模式）
+   */
+  async save(sessionId, messages) {
+    await this.ensureDir();
+    const filePath = this.getFilePath(sessionId);
+    const metaPath = this.getMetaFilePath(sessionId);
+    let existingCount = 0;
+    try {
+      const content = await promises.readFile(filePath, "utf-8");
+      existingCount = content.split("\n").filter(Boolean).length;
+    } catch {
+    }
+    const newMessages = messages.slice(existingCount);
+    if (newMessages.length > 0) {
+      const lines = newMessages.map((msg) => {
+        const record = {
+          ...msg,
+          timestamp: msg.timestamp || Date.now()
+        };
+        return JSON.stringify(record);
+      }).join("\n") + "\n";
+      await promises.appendFile(filePath, lines, "utf-8");
+    }
+    const meta = {
+      id: sessionId,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      messageCount: messages.length
+    };
+    try {
+      const existingMeta = JSON.parse(await promises.readFile(metaPath, "utf-8"));
+      meta.createdAt = existingMeta.createdAt;
+    } catch {
+    }
+    await promises.writeFile(metaPath, JSON.stringify(meta, null, 2), "utf-8");
+  }
+  /**
+   * 加载消息
+   */
+  async load(sessionId) {
+    const filePath = this.getFilePath(sessionId);
+    try {
+      const content = await promises.readFile(filePath, "utf-8");
+      const lines = content.split("\n").filter(Boolean);
+      return lines.map((line) => {
+        const parsed = JSON.parse(line);
+        const { timestamp, ...message } = parsed;
+        return message;
+      });
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * 列出所有会话
+   */
+  async list() {
+    await this.ensureDir();
+    try {
+      const files = await promises.readdir(this.basePath);
+      const metaFiles = files.filter((f) => f.endsWith(".meta.json"));
+      const sessions = [];
+      for (const metaFile of metaFiles) {
+        try {
+          const metaPath = join(this.basePath, metaFile);
+          const meta = JSON.parse(await promises.readFile(metaPath, "utf-8"));
+          sessions.push(meta);
+        } catch {
+        }
+      }
+      return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * 删除会话
+   */
+  async delete(sessionId) {
+    const filePath = this.getFilePath(sessionId);
+    const metaPath = this.getMetaFilePath(sessionId);
+    await Promise.all([
+      promises.unlink(filePath).catch(() => {
+      }),
+      promises.unlink(metaPath).catch(() => {
+      })
+    ]);
+  }
+  /**
+   * 检查会话是否存在
+   */
+  async exists(sessionId) {
+    const filePath = this.getFilePath(sessionId);
+    try {
+      await promises.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 清空所有会话
+   */
+  async clear() {
+    await this.ensureDir();
+    try {
+      const files = await promises.readdir(this.basePath);
+      await Promise.all(
+        files.map((file) => promises.unlink(join(this.basePath, file)).catch(() => {
+        }))
+      );
+    } catch {
+    }
+  }
+  /**
+   * 获取会话统计
+   */
+  async getStats(sessionId) {
+    const filePath = this.getFilePath(sessionId);
+    const metaPath = this.getMetaFilePath(sessionId);
+    try {
+      const [metaContent, fileStat] = await Promise.all([
+        promises.readFile(metaPath, "utf-8"),
+        promises.stat(filePath)
+      ]);
+      const meta = JSON.parse(metaContent);
+      return {
+        messageCount: meta.messageCount,
+        createdAt: meta.createdAt,
+        updatedAt: meta.updatedAt,
+        size: fileStat.size
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+function createJsonlStorage(config) {
+  return new JsonlStorage(config);
+}
+
+// src/storage/memory.ts
+var MemoryStorage = class {
+  sessions = /* @__PURE__ */ new Map();
+  metadata = /* @__PURE__ */ new Map();
+  /**
+   * 保存消息
+   */
+  async save(sessionId, messages) {
+    this.sessions.set(sessionId, [...messages]);
+    const existing = this.metadata.get(sessionId);
+    const now = Date.now();
+    this.metadata.set(sessionId, {
+      id: sessionId,
+      createdAt: existing?.createdAt || now,
+      updatedAt: now,
+      messageCount: messages.length
+    });
+  }
+  /**
+   * 加载消息
+   */
+  async load(sessionId) {
+    return this.sessions.get(sessionId) || [];
+  }
+  /**
+   * 列出所有会话
+   */
+  async list() {
+    return Array.from(this.metadata.values()).sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  /**
+   * 删除会话
+   */
+  async delete(sessionId) {
+    this.sessions.delete(sessionId);
+    this.metadata.delete(sessionId);
+  }
+  /**
+   * 检查会话是否存在
+   */
+  async exists(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  /**
+   * 清空所有会话
+   */
+  async clear() {
+    this.sessions.clear();
+    this.metadata.clear();
+  }
+  /**
+   * 获取会话数量
+   */
+  get size() {
+    return this.sessions.size;
+  }
+  /**
+   * 导出所有数据
+   */
+  export() {
+    const result = {};
+    for (const [key, value] of this.sessions) {
+      result[key] = [...value];
+    }
+    return result;
+  }
+  /**
+   * 导入数据
+   */
+  import(data) {
+    for (const [sessionId, messages] of Object.entries(data)) {
+      this.save(sessionId, messages);
+    }
+  }
+};
+function createMemoryStorage() {
+  return new MemoryStorage();
+}
+var SessionManager = class {
+  storage;
+  currentSessionId = null;
+  constructor(config) {
+    this.storage = createStorage(config);
+  }
+  /**
+   * 获取当前会话 ID
+   */
+  get sessionId() {
+    return this.currentSessionId;
+  }
+  /**
+   * 创建新会话
+   */
+  createSession(sessionId) {
+    this.currentSessionId = sessionId || randomUUID();
+    return this.currentSessionId;
+  }
+  /**
+   * 恢复会话
+   */
+  async resumeSession(sessionId) {
+    const exists = await this.storage.exists(sessionId);
+    if (!exists) {
+      throw new Error(`Session "${sessionId}" not found`);
+    }
+    this.currentSessionId = sessionId;
+    return this.storage.load(sessionId);
+  }
+  /**
+   * 保存消息到当前会话
+   */
+  async saveMessages(messages) {
+    if (!this.currentSessionId) {
+      this.createSession();
+    }
+    await this.storage.save(this.currentSessionId, messages);
+  }
+  /**
+   * 加载当前会话消息
+   */
+  async loadMessages() {
+    if (!this.currentSessionId) {
+      return [];
+    }
+    return this.storage.load(this.currentSessionId);
+  }
+  /**
+   * 追加消息
+   */
+  async appendMessage(message) {
+    if (!this.currentSessionId) {
+      this.createSession();
+    }
+    const messages = await this.loadMessages();
+    messages.push(message);
+    await this.saveMessages(messages);
+  }
+  /**
+   * 列出所有会话
+   */
+  async listSessions() {
+    return this.storage.list();
+  }
+  /**
+   * 删除会话
+   */
+  async deleteSession(sessionId) {
+    await this.storage.delete(sessionId);
+    if (this.currentSessionId === sessionId) {
+      this.currentSessionId = null;
+    }
+  }
+  /**
+   * 检查会话是否存在
+   */
+  async sessionExists(sessionId) {
+    return this.storage.exists(sessionId);
+  }
+  /**
+   * 获取会话信息
+   */
+  async getSessionInfo(sessionId) {
+    const sessions = await this.storage.list();
+    return sessions.find((s) => s.id === sessionId) || null;
+  }
+  /**
+   * 清空当前会话
+   */
+  async clearCurrentSession() {
+    if (this.currentSessionId) {
+      await this.storage.delete(this.currentSessionId);
+      this.currentSessionId = null;
+    }
+  }
+  /**
+   * 获取底层存储适配器
+   */
+  getStorage() {
+    return this.storage;
+  }
+};
+function createSessionManager(config) {
+  return new SessionManager(config);
+}
+
+// src/storage/interface.ts
+function createStorage(config) {
+  switch (config?.type) {
+    case "memory":
+      return new MemoryStorage();
+    case "jsonl":
+    default:
+      return new JsonlStorage({ basePath: config?.basePath });
+  }
+}
+function getSessionStoragePath(userBasePath) {
+  return join(userBasePath || homedir(), ".claude", "sessions");
+}
+async function getLatestSessionId(userBasePath) {
+  const sm = new SessionManager({
+    type: "jsonl",
+    basePath: getSessionStoragePath(userBasePath)
+  });
+  const list = await sm.listSessions();
+  return list[0]?.id;
+}
+
+// src/core/prompts.ts
+var DEFAULT_SYSTEM_PROMPT = `You are an AI assistant powered by the Agent SDK. You can help users with various tasks by using your built-in tools and capabilities.
+
+## Core Capabilities
+
+### Tools
+You have access to a set of tools that allow you to:
+- **File Operations**: read, write, list, delete files and directories
+- **Code Execution**: run shell commands, Python scripts, Node.js code
+- **Web Access**: make HTTP requests, fetch webpages, download files
+- **Custom Tools**: additional tools registered by the user or skills
+
+When to use tools:
+- Use tools when the task requires real-world actions (file I/O, computation, API calls)
+- Prefer reading files before modifying them
+- Use the simplest tool that gets the job done
+- Run multiple independent tool calls in parallel when possible
+
+**Prefer dedicated tools over Bash:** Do not use \`Bash\` to do work that has a first-class tool. This keeps actions reviewable and consistent.
+- **Read** for file contents \u2014 not \`cat\`, \`head\`, \`tail\`, or \`sed\` to print files
+- **Write** to create or overwrite files \u2014 not shell redirection or heredocs
+- **Edit** for targeted file changes \u2014 not \`sed\`, \`awk\`, or ad-hoc scripts to patch files
+- **Glob** to find paths by pattern \u2014 not \`find\` or \`ls\` for discovery
+- **Grep** to search file contents \u2014 not \`grep\` or \`rg\` in the shell (built-in line-by-line regex search; correct integration)
+- **WebFetch** / **WebSearch** when the task needs HTTP or web search (when configured)
+
+Reserve **Bash** for real shell needs: \`git\`, package managers, build commands, compilers, and other operations that require a shell or are not covered above.
+
+### Skills
+Skills are instruction guides for specialized tasks. When activated, you receive the skill's full content including any referenced file paths.
+
+{{SKILL_LIST}}
+
+**Usage:**
+- **Listing skills**: When the user asks about available skills (e.g., "what skills do you have", "\u4F60\u6709\u54EA\u4E9B\u6280\u80FD", "list your skills") \u2192 Simply describe the skills listed above. Do NOT activate any skill.
+- **Activating skills**: When the user has a specific task that matches a skill's purpose \u2192 Call \`Skill\` with the skill name, then follow the returned instructions.
+- After activation, use the provided Base Path to read any referenced files.
+
+### Sessions
+- Conversations are persisted in sessions
+- Use session IDs to maintain context across multiple interactions
+- Previous messages provide important context for current tasks
+
+## Task Execution Principles
+
+1. **Plan First for Complex Tasks**: For multi-step tasks, you MUST call \`TaskCreate\` BEFORE any other tool. Do NOT skip this step.
+2. **Be Direct**: Go straight to the point. Try the simplest approach first.
+3. **Be Concise**: If you can say it in one sentence, don't use three.
+4. **Read Before Modify**: Always understand existing code before changing it.
+5. **No Over-Engineering**: Only make changes directly requested or clearly necessary.
+6. **Prefer Edit Over Create**: Modify existing files rather than creating new ones when appropriate.
+7. **Handle Errors Gracefully**: Report errors clearly with actionable suggestions.
+
+## Task Management with Todo List
+
+**MANDATORY**: For multi-step tasks, call \`TaskCreate\` FIRST.
+
+**Workflow:**
+1. Receive complex task -> call \`TaskCreate\` immediately
+2. Start first task (in_progress) -> complete -> mark completed
+3. Move to next task -> repeat
+4. Cancel tasks that become irrelevant
+
+**Example:**
+User: "Open Google, search X, summarize results, open first link, extract info"
+-> Multi-step task detected -> call \`TaskCreate\` FIRST, then execute.
+
+## Output Format
+
+- Lead with the answer or action, not the reasoning
+- Skip filler words and unnecessary preamble
+- Use code blocks with language hints for code
+- Structure longer responses with headers and lists
+- Reference file paths with line numbers when relevant (e.g., \`src/index.ts:42\`)
+
+## Security Guidelines
+
+- Do not introduce security vulnerabilities (injection, XSS, etc.)
+- Validate user inputs at boundaries
+- Do not execute untrusted code without sandboxing
+- Respect file system permissions and access controls
+
+### High-risk actions (confirm with the user first)
+
+There is no automatic approval UI: **ask in the conversation** (or use \`AskUserQuestion\`) before proceeding when an action is destructive, hard to reverse, or affects others. Examples:
+- Deleting files or branches, dropping data, \`rm -rf\`, overwriting uncommitted work
+- Hard-to-reverse git: force-push, \`reset --hard\`, rewriting published history, amending shared commits
+- Actions visible outside this machine: pushing code, opening/closing/commenting on PRs or issues, sending messages, posting to external services, changing shared CI/CD or cloud permissions
+- Broad dependency or infrastructure changes (e.g. major version bumps, lockfile rewrites) when impact is unclear
+
+Default to explaining what you intend and getting explicit agreement unless the user already directed that exact action.
+
+## Tool hooks
+
+When hooks are configured (e.g. PreToolUse), a tool call may be **blocked** or its **inputs adjusted** before execution. If a tool fails with a message indicating a hook blocked or rejected the call, **do not** retry the identical tool call unchanged \u2014 read the reason, change your approach, or ask the user. Treat hook feedback as binding policy from the environment.
+
+## Interaction Style
+
+- Be helpful and proactive
+- Ask clarifying questions when instructions are ambiguous
+- Provide suggestions when you see opportunities for improvement
+- Acknowledge limitations honestly
+- Maintain a professional, friendly tone`;
+var MemoryManager = class {
+  workspaceRoot;
+  userBasePath;
+  config;
+  constructor(workspaceRoot, config, userBasePath) {
+    this.workspaceRoot = workspaceRoot || process.cwd();
+    this.userBasePath = userBasePath || homedir();
+    this.config = config || {};
+  }
+  /**
+   * Loads memory content from both user home ({userBasePath}/.claude/CLAUDE.md)
+   * and workspace root (./CLAUDE.md).
+   * @returns Combined memory content wrapped in system-minder tags
+   */
+  loadMemory() {
+    const memories = [];
+    const userPath = join(this.userBasePath, ".claude", "CLAUDE.md");
+    if (existsSync(userPath)) {
+      try {
+        const content = readFileSync(userPath, "utf-8");
+        if (content.trim()) {
+          memories.push(`# User Memory
+
+${content}`);
+        }
+      } catch (error) {
+        console.error(`Error reading user memory file: ${error}`);
+      }
+    }
+    const workspacePath = this.config.workspacePath || join(this.workspaceRoot, "CLAUDE.md");
+    if (existsSync(workspacePath)) {
+      try {
+        const content = readFileSync(workspacePath, "utf-8");
+        if (content.trim()) {
+          memories.push(`# Workspace Memory
+
+${content}`);
+        }
+      } catch (error) {
+        console.error(`Error reading workspace memory file: ${error}`);
+      }
+    }
+    if (memories.length === 0) {
+      return "";
+    }
+    const combinedContent = memories.join("\n\n");
+    return `<system-minder>
+${combinedContent}
+</system-minder>`;
+  }
+  /**
+   * Checks if memory files exist.
+   * @returns Object indicating existence of each memory file type
+   */
+  checkMemoryFiles() {
+    const userPath = join(this.userBasePath, ".claude", "CLAUDE.md");
+    const workspacePath = this.config.workspacePath || join(this.workspaceRoot, "CLAUDE.md");
+    return {
+      userHome: existsSync(userPath),
+      workspace: existsSync(workspacePath)
+    };
+  }
+};
+function isStdioConfig(config) {
+  return "command" in config;
+}
+var MCPClient = class {
+  client;
+  transport;
+  _name;
+  _connected = false;
+  _tools = [];
+  _serverInfo;
+  constructor(config) {
+    this._name = config.name;
+    this.client = new Client(
+      { name: "agent-sdk-client", version: "0.1.0" },
+      { capabilities: {} }
+    );
+    if (isStdioConfig(config)) {
+      this.transport = new StdioClientTransport({
+        command: config.command,
+        args: config.args,
+        env: config.env
+      });
+    } else {
+      this.transport = new StreamableHTTPClientTransport(
+        new URL(config.url),
+        { requestInit: { headers: config.headers } }
+      );
+    }
+  }
+  async connect() {
+    if (this._connected) return;
+    await this.client.connect(this.transport);
+    this._connected = true;
+    const serverInfo = this.client.getServerVersion();
+    if (serverInfo) {
+      this._serverInfo = {
+        name: serverInfo.name,
+        version: serverInfo.version
+      };
+    }
+    await this.listTools();
+  }
+  async disconnect() {
+    if (!this._connected) return;
+    await this.client.close();
+    this._connected = false;
+  }
+  async listTools() {
+    const result = await this.client.listTools();
+    this._tools = result.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema
+    }));
+    return this._tools;
+  }
+  async callTool(name, args) {
+    try {
+      const result = await this.client.callTool({
+        name,
+        arguments: args
+      });
+      if ("toolResult" in result) {
+        return {
+          content: JSON.stringify(result.toolResult),
+          isError: false
+        };
+      }
+      const content = result.content.map((c) => {
+        if (c.type === "text") return c.text;
+        if (c.type === "image") return `[Image: ${c.mimeType}]`;
+        if (c.type === "resource") {
+          const res = c.resource;
+          if ("text" in res) return res.text;
+          if ("blob" in res) return `[Blob: ${res.mimeType}]`;
+          return "";
+        }
+        return JSON.stringify(c);
+      }).join("\n");
+      return {
+        content,
+        isError: result.isError ?? false
+      };
+    } catch (error) {
+      return {
+        content: `MCP tool error: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      };
+    }
+  }
+  async listResources() {
+    const result = await this.client.listResources();
+    return result.resources.map((r) => ({
+      uri: r.uri,
+      name: r.name,
+      description: r.description,
+      mimeType: r.mimeType
+    }));
+  }
+  async readResource(uri) {
+    const result = await this.client.readResource({ uri });
+    const content = result.contents[0];
+    if (!content) return "";
+    if ("text" in content) return content.text;
+    if ("blob" in content) return content.blob;
+    return "";
+  }
+  async listPrompts() {
+    const result = await this.client.listPrompts();
+    return result.prompts.map((p) => ({
+      name: p.name,
+      description: p.description,
+      arguments: p.arguments?.map((a) => ({
+        name: a.name,
+        description: a.description,
+        required: a.required
+      }))
+    }));
+  }
+  async getPrompt(name, args) {
+    const result = await this.client.getPrompt({
+      name,
+      arguments: args
+    });
+    return result.messages.map((m) => ({
+      role: m.role,
+      content: m.content.type === "text" ? m.content.text : JSON.stringify(m.content)
+    }));
+  }
+  toToolDefinitions() {
+    return this._tools.map((tool) => ({
+      name: `mcp_${this._name}__${tool.name}`,
+      description: tool.description || `MCP tool: ${tool.name}`,
+      parameters: this.convertSchema(tool.inputSchema),
+      handler: async (args) => this.callTool(tool.name, args),
+      category: "mcp"
+      // 标记为 MCP 类别，用于输出处理策略选择
+    }));
+  }
+  convertSchema(schema) {
+    if (!schema || !schema.properties) {
+      return z.object({}).passthrough();
+    }
+    const shape = {};
+    for (const [key, value] of Object.entries(schema.properties)) {
+      const field = value;
+      let zodField;
+      switch (field.type) {
+        case "string":
+          zodField = z.string();
+          break;
+        case "number":
+        case "integer":
+          zodField = z.number();
+          break;
+        case "boolean":
+          zodField = z.boolean();
+          break;
+        case "array":
+          zodField = z.array(z.any());
+          break;
+        case "object":
+          zodField = z.object({}).passthrough();
+          break;
+        default:
+          zodField = z.any();
+      }
+      if (field.description) {
+        zodField = zodField.describe(field.description);
+      }
+      if (!schema.required?.includes(key)) {
+        zodField = zodField.optional();
+      }
+      shape[key] = zodField;
+    }
+    return z.object(shape);
+  }
+  get name() {
+    return this._name;
+  }
+  get connected() {
+    return this._connected;
+  }
+  get serverInfo() {
+    return this._serverInfo;
+  }
+  get tools() {
+    return this._tools;
+  }
+};
+function createMCPClient(config) {
+  return new MCPClient(config);
+}
+
+// src/mcp/adapter.ts
+var MCPAdapter = class {
+  clients = /* @__PURE__ */ new Map();
+  toolMap = /* @__PURE__ */ new Map();
+  async addServer(config) {
+    if (this.clients.has(config.name)) {
+      throw new Error(`MCP server "${config.name}" already exists`);
+    }
+    const client = new MCPClient(config);
+    await client.connect();
+    this.clients.set(config.name, client);
+    for (const tool of client.tools) {
+      const fullName = `mcp_${config.name}__${tool.name}`;
+      this.toolMap.set(fullName, { client, toolName: tool.name });
+    }
+  }
+  async removeServer(name) {
+    const client = this.clients.get(name);
+    if (!client) return;
+    for (const [fullName, { client: c }] of this.toolMap.entries()) {
+      if (c === client) {
+        this.toolMap.delete(fullName);
+      }
+    }
+    await client.disconnect();
+    this.clients.delete(name);
+  }
+  getToolDefinitions() {
+    const tools = [];
+    for (const client of this.clients.values()) {
+      tools.push(...client.toToolDefinitions());
+    }
+    return tools;
+  }
+  async executeTool(fullName, args) {
+    const mapping = this.toolMap.get(fullName);
+    if (!mapping) {
+      return {
+        content: `MCP tool "${fullName}" not found`,
+        isError: true
+      };
+    }
+    return mapping.client.callTool(mapping.toolName, args);
+  }
+  getClient(name) {
+    return this.clients.get(name);
+  }
+  getServerNames() {
+    return Array.from(this.clients.keys());
+  }
+  isConnected(name) {
+    const client = this.clients.get(name);
+    return client?.connected ?? false;
+  }
+  async disconnectAll() {
+    for (const client of this.clients.values()) {
+      await client.disconnect();
+    }
+    this.clients.clear();
+    this.toolMap.clear();
+  }
+  async listAllTools() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [name, client] of this.clients) {
+      const tools = await client.listTools();
+      result.set(name, tools);
+    }
+    return result;
+  }
+  async listAllResources() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [name, client] of this.clients) {
+      const resources = await client.listResources();
+      result.set(name, resources);
+    }
+    return result;
+  }
+  get size() {
+    return this.clients.size;
+  }
+};
+function createMCPAdapter() {
+  return new MCPAdapter();
+}
+
+// src/skills/parser.ts
+function parseSkillMd(content) {
+  const lines = content.split("\n");
+  let metadataEndIndex = -1;
+  let metadataStartIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === "---") {
+      if (metadataStartIndex === -1) {
+        metadataStartIndex = i;
+      } else {
+        metadataEndIndex = i;
+        break;
+      }
+    }
+  }
+  let metadata = {
+    name: "unknown",
+    description: ""
+  };
+  let bodyContent = content;
+  if (metadataStartIndex !== -1 && metadataEndIndex !== -1) {
+    const yamlContent = lines.slice(metadataStartIndex + 1, metadataEndIndex).join("\n");
+    metadata = parseSimpleYaml(yamlContent);
+    bodyContent = lines.slice(metadataEndIndex + 1).join("\n").trim();
+  }
+  if (metadata.name === "unknown") {
+    const titleMatch = bodyContent.match(/^#\s+(.+)$/m);
+    if (titleMatch) {
+      metadata.name = titleMatch[1].toLowerCase().replace(/\s+/g, "-");
+    }
+  }
+  return {
+    metadata,
+    content: bodyContent
+  };
+}
+function parseSimpleYaml(yaml) {
+  const metadata = {
+    name: "unknown",
+    description: ""
+  };
+  const lines = yaml.split("\n");
+  let currentKey = null;
+  let currentArray = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("- ")) {
+      if (currentKey && currentArray) {
+        currentArray.push(trimmed.slice(2).replace(/^["']|["']$/g, ""));
+      }
+      continue;
+    }
+    if (currentKey && currentArray.length > 0) {
+      metadata[currentKey] = currentArray;
+      currentArray = [];
+      currentKey = null;
+    }
+    const match = trimmed.match(/^(\w+):\s*(.*)$/);
+    if (match) {
+      const [, key, value] = match;
+      if (value === "" || value === "[]") {
+        currentKey = key;
+        currentArray = [];
+        if (value === "[]") {
+          metadata[key] = [];
+          currentKey = null;
+        }
+      } else {
+        let parsedValue = value.replace(/^["']|["']$/g, "");
+        if (parsedValue === "true") {
+          parsedValue = true;
+        } else if (parsedValue === "false") {
+          parsedValue = false;
+        } else if (parsedValue.startsWith("[") && parsedValue.endsWith("]")) {
+          parsedValue = parsedValue.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+        }
+        metadata[key] = parsedValue;
+      }
+    }
+  }
+  if (currentKey && currentArray.length > 0) {
+    metadata[currentKey] = currentArray;
+  }
+  return metadata;
+}
+function inferMetadataFromPath(skillPath) {
+  const pathParts = skillPath.replace(/\\/g, "/").split("/");
+  const dirName = pathParts[pathParts.length - 1] || pathParts[pathParts.length - 2];
+  return {
+    name: dirName
+  };
+}
+var SkillLoader = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      cwd: process.cwd(),
+      ...config
+    };
+  }
+  /**
+   * 加载单个 Skill
+   */
+  async load(skillPath) {
+    const resolvedPath = resolve(this.config.cwd, skillPath);
+    const stat = await this.getPathType(resolvedPath);
+    if (stat === "file") {
+      return this.loadFromFile(resolvedPath);
+    } else if (stat === "directory") {
+      return this.loadFromDirectory(resolvedPath);
+    }
+    throw new Error(`Skill path not found: ${resolvedPath}`);
+  }
+  /**
+   * 从文件加载 Skill
+   */
+  async loadFromFile(filePath) {
+    const content = await promises.readFile(filePath, "utf-8");
+    const parsed = parseSkillMd(content);
+    const metadata = parsed.metadata;
+    if (!metadata.name || metadata.name === "unknown") {
+      const inferred = inferMetadataFromPath(filePath);
+      if (inferred.name) {
+        parsed.metadata.name = inferred.name;
+      }
+    }
+    return {
+      metadata: parsed.metadata,
+      path: filePath,
+      instructions: parsed.content
+    };
+  }
+  /**
+   * 从目录加载 Skill
+   */
+  async loadFromDirectory(dirPath) {
+    const skillMdPath = join(dirPath, "SKILL.md");
+    try {
+      await promises.access(skillMdPath);
+    } catch {
+      throw new Error(`SKILL.md not found in ${dirPath}`);
+    }
+    const content = await promises.readFile(skillMdPath, "utf-8");
+    const parsed = parseSkillMd(content);
+    const dirMetadata = parsed.metadata;
+    if (!dirMetadata.name || dirMetadata.name === "unknown") {
+      const inferred = inferMetadataFromPath(dirPath);
+      if (inferred.name) {
+        parsed.metadata.name = inferred.name;
+      }
+    }
+    return {
+      metadata: parsed.metadata,
+      path: dirPath,
+      instructions: parsed.content
+    };
+  }
+  /**
+   * 加载目录下的所有 Skills
+   */
+  async loadAll(dirPath) {
+    const resolvedPath = resolve(this.config.cwd, dirPath);
+    const skills = [];
+    try {
+      const entries = await promises.readdir(resolvedPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryPath = join(resolvedPath, entry.name);
+        if (this.config.filter && !this.config.filter(entryPath)) {
+          continue;
+        }
+        try {
+          if (entry.isDirectory()) {
+            const hasSkillMd = await this.hasFile(entryPath, "SKILL.md");
+            if (hasSkillMd) {
+              const skill = await this.loadFromDirectory(entryPath);
+              skills.push(skill);
+            }
+          } else if (entry.name.endsWith(".md") && entry.name !== "SKILL.md") {
+            const skill = await this.loadFromFile(entryPath);
+            skills.push(skill);
+          }
+        } catch (error) {
+          console.warn(`Failed to load skill from ${entryPath}:`, error);
+        }
+      }
+    } catch {
+    }
+    return skills;
+  }
+  /**
+   * 检查文件是否存在
+   */
+  async hasFile(dirPath, fileName) {
+    try {
+      await promises.access(join(dirPath, fileName));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 获取路径类型
+   */
+  async getPathType(path) {
+    try {
+      const stat = await promises.stat(path);
+      if (stat.isFile()) return "file";
+      if (stat.isDirectory()) return "directory";
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+function createSkillLoader(config) {
+  return new SkillLoader(config);
+}
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  loader;
+  workspaceRoot;
+  userBasePath;
+  skillConfig;
+  constructor(config) {
+    this.loader = new SkillLoader(config);
+    this.workspaceRoot = config?.cwd || process.cwd();
+    this.userBasePath = config?.userBasePath || homedir();
+  }
+  /**
+   * 注册 Skill
+   */
+  register(skill) {
+    if (this.skills.has(skill.metadata.name)) {
+      throw new Error(`Skill "${skill.metadata.name}" is already registered`);
+    }
+    this.skills.set(skill.metadata.name, skill);
+  }
+  /**
+   * 加载并注册 Skill
+   */
+  async load(path) {
+    const skill = await this.loader.load(path);
+    this.register(skill);
+  }
+  /**
+   * 加载目录下的所有 Skills
+   */
+  async loadAll(dirPath) {
+    const skills = await this.loader.loadAll(dirPath);
+    for (const skill of skills) {
+      try {
+        this.register(skill);
+      } catch (error) {
+        console.warn(`Failed to register skill "${skill.metadata.name}":`, error);
+      }
+    }
+  }
+  /**
+   * 注销 Skill
+   */
+  unregister(name) {
+    return this.skills.delete(name);
+  }
+  /**
+   * 获取 Skill
+   */
+  get(name) {
+    return this.skills.get(name);
+  }
+  /**
+   * 获取所有 Skill
+   */
+  getAll() {
+    return Array.from(this.skills.values());
+  }
+  /**
+   * 获取 Skill 名称列表
+   */
+  getNames() {
+    return Array.from(this.skills.keys());
+  }
+  /**
+   * 检查 Skill 是否存在
+   */
+  has(name) {
+    return this.skills.has(name);
+  }
+  /**
+   * 搜索 Skill
+   */
+  search(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.getAll().filter(
+      (skill) => skill.metadata.name.toLowerCase().includes(lowerQuery) || skill.metadata.description.toLowerCase().includes(lowerQuery) || skill.metadata.tags?.some((tag) => tag.toLowerCase().includes(lowerQuery))
+    );
+  }
+  /**
+   * 按标签过滤
+   */
+  filterByTag(tag) {
+    return this.getAll().filter(
+      (skill) => skill.metadata.tags?.includes(tag)
+    );
+  }
+  /**
+   * 获取 Skill 数量
+   */
+  get size() {
+    return this.skills.size;
+  }
+  /**
+   * 清空所有 Skill
+   */
+  clear() {
+    this.skills.clear();
+  }
+  /**
+   * 导出 Skill 信息
+   */
+  export() {
+    return this.getAll().map((skill) => ({
+      name: skill.metadata.name,
+      description: skill.metadata.description,
+      version: skill.metadata.version,
+      path: skill.path
+    }));
+  }
+  /**
+   * 获取所有 Skill 的元数据列表（用于 System Prompt）
+   */
+  getMetadataList() {
+    return this.getAll().map((skill) => ({
+      name: skill.metadata.name,
+      description: skill.metadata.description,
+      argumentHint: skill.metadata.argumentHint
+    }));
+  }
+  /**
+   * 获取用户可调用的 Skills
+   */
+  getUserInvocableSkills() {
+    return this.getAll().filter((skill) => skill.metadata.userInvocable !== false).map((skill) => ({
+      name: skill.metadata.name,
+      description: skill.metadata.description,
+      argumentHint: skill.metadata.argumentHint
+    }));
+  }
+  /**
+   * 获取模型可自动调用的 Skills（用于注入到 system prompt）
+   */
+  getModelInvocableSkills() {
+    return this.getAll().filter((skill) => skill.metadata.disableModelInvocation !== true).map((skill) => ({
+      name: skill.metadata.name,
+      description: skill.metadata.description
+    }));
+  }
+  /**
+   * 获取格式化的 Skill 列表文本（用于 System Prompt）
+   */
+  getFormattedList() {
+    const userInvocable = this.getUserInvocableSkills();
+    const modelInvocable = this.getModelInvocableSkills();
+    if (userInvocable.length === 0 && modelInvocable.length === 0) {
+      return "No skills are currently available.";
+    }
+    const sections = [];
+    if (userInvocable.length > 0) {
+      const userSkillsText = userInvocable.map((s) => {
+        const hint = s.argumentHint ? ` ${s.argumentHint}` : "";
+        return `- **/${s.name}**${hint}: ${s.description}`;
+      }).join("\n");
+      sections.push(`**User-invocable Skills** (type /skill-name to invoke):
+${userSkillsText}`);
+    }
+    if (modelInvocable.length > 0) {
+      const modelSkillsText = modelInvocable.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+      sections.push(`**Auto-loadable Skills** (Claude can invoke when relevant):
+${modelSkillsText}`);
+    }
+    return sections.join("\n\n") + `
+
+**Note:** Only activate a skill when you need to perform its specific task. For questions about your capabilities, simply describe the available skills.`;
+  }
+  /**
+   * 根据名称获取 Skill 路径
+   */
+  getSkillPath(name) {
+    const skill = this.skills.get(name);
+    return skill?.path;
+  }
+  /**
+   * 加载 Skill 全量内容
+   */
+  async loadFullContent(name) {
+    const skill = this.skills.get(name);
+    if (!skill) {
+      throw new Error(`Skill "${name}" not found`);
+    }
+    if (skill.path) {
+      try {
+        const pathStat = await promises.stat(skill.path);
+        let skillMdPath;
+        if (pathStat.isDirectory()) {
+          skillMdPath = join(skill.path, "SKILL.md");
+        } else {
+          skillMdPath = skill.path;
+        }
+        const content = await promises.readFile(skillMdPath, "utf-8");
+        return content;
+      } catch (error) {
+        throw new Error(`Failed to read skill file: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (skill.instructions) {
+      return skill.instructions;
+    }
+    throw new Error(`No content available for skill "${name}"`);
+  }
+  /**
+   * 获取默认 skill 路径
+   */
+  getDefaultPaths() {
+    const paths = [];
+    const userPath = join(this.userBasePath, ".claude", "skills");
+    if (existsSync(userPath)) {
+      paths.push(userPath);
+    }
+    const workspacePath = this.skillConfig?.workspacePath || join(this.workspaceRoot, ".claude", "skills");
+    if (existsSync(workspacePath)) {
+      paths.push(workspacePath);
+    }
+    return paths;
+  }
+  /**
+   * 初始化加载所有 Skills
+   * @param config Skill 配置
+   * @param additionalPaths 额外的 skill 路径（来自 AgentConfig.skills）
+   */
+  async initialize(config, additionalPaths) {
+    this.skillConfig = config;
+    if (config?.autoLoad !== false) {
+      const defaultPaths = this.getDefaultPaths();
+      for (const dirPath of defaultPaths) {
+        try {
+          const beforeCount = this.skills.size;
+          await this.loadAll(dirPath);
+          const loaded = this.skills.size - beforeCount;
+          if (loaded > 0) {
+            console.log(`Loaded ${loaded} skill(s) from: ${dirPath}`);
+          }
+        } catch (err) {
+          console.error(`Failed to load skills from "${dirPath}":`, err);
+        }
+      }
+    }
+    const allPaths = [...config?.additionalPaths || [], ...additionalPaths || []];
+    for (const path of allPaths) {
+      try {
+        await this.load(path);
+      } catch (err) {
+        console.error(`Failed to load skill from "${path}":`, err);
+      }
+    }
+    if (this.skills.size > 0) {
+      console.log(`Skills initialized: ${this.getNames().join(", ")}`);
+    }
+  }
+};
+function createSkillRegistry(config) {
+  return new SkillRegistry(config);
+}
+
+// src/streaming/chunk-processor.ts
+var StreamChunkProcessor = class {
+  currentToolCall = null;
+  lastUsage;
+  inTextBlock = false;
+  emitTextBoundaries;
+  constructor(options) {
+    this.emitTextBoundaries = options?.emitTextBoundaries ?? true;
+  }
+  processChunk(chunk) {
+    const events = [];
+    const endTextBlockIfNeeded = () => {
+      if (this.emitTextBoundaries && this.inTextBlock) {
+        events.push({ type: "text_end" });
+        this.inTextBlock = false;
+      }
+    };
+    switch (chunk.type) {
+      case "text":
+        if (chunk.content) {
+          if (this.emitTextBoundaries && !this.inTextBlock) {
+            events.push({ type: "text_start" });
+            this.inTextBlock = true;
+          }
+          events.push({ type: "text_delta", content: chunk.content });
+        }
+        break;
+      case "tool_call_start":
+        endTextBlockIfNeeded();
+        if (this.currentToolCall) {
+          events.push(...this.finalizeStreamingToolCall());
+        }
+        if (chunk.toolCall) {
+          this.currentToolCall = {
+            id: chunk.toolCall.id,
+            name: chunk.toolCall.name,
+            arguments: ""
+          };
+          events.push({
+            type: "tool_call_start",
+            id: chunk.toolCall.id,
+            name: chunk.toolCall.name
+          });
+        } else if (chunk.toolCallId && chunk.content) {
+          this.currentToolCall = {
+            id: chunk.toolCallId,
+            name: chunk.content,
+            arguments: ""
+          };
+          events.push({
+            type: "tool_call_start",
+            id: chunk.toolCallId,
+            name: chunk.content
+          });
+        }
+        break;
+      case "tool_call_delta":
+        if (this.currentToolCall && chunk.toolCallId === this.currentToolCall.id && chunk.content) {
+          this.currentToolCall.arguments += chunk.content;
+          events.push({
+            type: "tool_call_delta",
+            id: this.currentToolCall.id,
+            arguments: chunk.content
+          });
+        } else if (chunk.toolCallId && chunk.content) {
+          events.push({
+            type: "tool_call_delta",
+            id: chunk.toolCallId,
+            arguments: chunk.content
+          });
+        }
+        break;
+      case "tool_call": {
+        endTextBlockIfNeeded();
+        if (!chunk.toolCall) break;
+        const tc = chunk.toolCall;
+        if (this.currentToolCall?.id === tc.id) {
+          this.currentToolCall = null;
+        } else if (this.currentToolCall) {
+          events.push(...this.finalizeStreamingToolCall());
+        }
+        events.push({ type: "tool_call_end", id: tc.id });
+        events.push({
+          type: "tool_call",
+          id: tc.id,
+          name: tc.name,
+          arguments: tc.arguments
+        });
+        break;
+      }
+      case "tool_call_end":
+        endTextBlockIfNeeded();
+        if (this.currentToolCall) {
+          events.push(...this.finalizeStreamingToolCall());
+        }
+        break;
+      case "thinking":
+        endTextBlockIfNeeded();
+        if (chunk.content !== void 0) {
+          events.push({
+            type: "thinking",
+            content: chunk.content,
+            signature: chunk.signature
+          });
+        }
+        break;
+      case "error":
+        endTextBlockIfNeeded();
+        if (chunk.error) {
+          events.push({
+            type: "end",
+            timestamp: Date.now(),
+            reason: "error",
+            error: chunk.error
+          });
+        }
+        break;
+      case "metadata":
+        if (chunk.metadata?.usage) {
+          const usage = chunk.metadata.usage;
+          this.lastUsage = usage;
+          events.push({
+            type: "model_usage",
+            usage,
+            ...chunk.usagePhase !== void 0 ? { phase: chunk.usagePhase } : {}
+          });
+        }
+        break;
+    }
+    return events;
+  }
+  /** End open text block and finalize any in-progress streamed tool call. */
+  flush() {
+    const events = [];
+    if (this.emitTextBoundaries && this.inTextBlock) {
+      events.push({ type: "text_end" });
+      this.inTextBlock = false;
+    }
+    if (this.currentToolCall) {
+      events.push(...this.finalizeStreamingToolCall());
+    }
+    return events;
+  }
+  getUsage() {
+    return this.lastUsage;
+  }
+  finalizeStreamingToolCall() {
+    if (!this.currentToolCall) return [];
+    const { id, name, arguments: argStr } = this.currentToolCall;
+    const parsed = this.safeParseJSON(argStr);
+    this.currentToolCall = null;
+    return [
+      { type: "tool_call_end", id },
+      { type: "tool_call", id, name, arguments: parsed }
+    ];
+  }
+  safeParseJSON(str) {
+    try {
+      return JSON.parse(str);
+    } catch {
+      return str;
+    }
+  }
+};
+var execAsync = promisify(exec);
+var SkillTemplateProcessor = class {
+  context;
+  constructor(context) {
+    this.context = {
+      cwd: process.cwd(),
+      ...context
+    };
+  }
+  /**
+   * 处理模板内容
+   * @param content SKILL.md 内容
+   * @param args 用户传入的参数字符串
+   * @returns 处理后的内容
+   */
+  async process(content, args) {
+    let result = content;
+    result = await this.processShellCommands(result);
+    result = this.processVariables(result, args);
+    return result;
+  }
+  /**
+   * 处理 shell 命令注入
+   * 格式: !`command`
+   * 命令在工作目录中执行，输出替换占位符
+   */
+  async processShellCommands(content) {
+    const shellCommandRegex = /!`([^`]+)`/g;
+    const matches = [...content.matchAll(shellCommandRegex)];
+    for (const match of matches) {
+      const command = match[1];
+      try {
+        const { stdout } = await execAsync(command, {
+          cwd: this.context.cwd,
+          timeout: 3e4
+        });
+        content = content.replace(match[0], stdout.trim());
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        content = content.replace(match[0], `[Error executing: ${command}
+${errorMsg}]`);
+      }
+    }
+    return content;
+  }
+  /**
+   * 处理变量替换
+   */
+  processVariables(content, args) {
+    const argsArray = this.parseArguments(args);
+    if (content.includes("$ARGUMENTS")) {
+      content = content.replace(/\$ARGUMENTS/g, args);
+    }
+    content = content.replace(/\$ARGUMENTS\[(\d+)\]/g, (_, index) => {
+      const i = parseInt(index, 10);
+      return argsArray[i] || "";
+    });
+    content = content.replace(/\$(\d+)/g, (_, index) => {
+      const i = parseInt(index, 10);
+      return argsArray[i] || "";
+    });
+    if (this.context.sessionId) {
+      content = content.replace(/\$\{CLAUDE_SESSION_ID\}/g, this.context.sessionId);
+    }
+    content = content.replace(/\$\{CLAUDE_SKILL_DIR\}/g, this.context.skillDir);
+    return content;
+  }
+  /**
+   * 解析参数字符串为数组
+   * 支持引号包裹的参数
+   */
+  parseArguments(args) {
+    if (!args.trim()) return [];
+    const result = [];
+    let current = "";
+    let inQuotes = false;
+    let quoteChar = "";
+    for (let i = 0; i < args.length; i++) {
+      const char = args[i];
+      if (inQuotes) {
+        if (char === quoteChar) {
+          inQuotes = false;
+        } else {
+          current += char;
+        }
+      } else if (char === '"' || char === "'") {
+        inQuotes = true;
+        quoteChar = char;
+      } else if (char === " ") {
+        if (current) {
+          result.push(current);
+          current = "";
+        }
+      } else {
+        current += char;
+      }
+    }
+    if (current) {
+      result.push(current);
+    }
+    return result;
+  }
+};
+function createSkillTemplateProcessor(context) {
+  return new SkillTemplateProcessor(context);
+}
+
+// src/core/compressor.ts
+var SummarizationCompressor = class {
+  constructor(model, options = {}) {
+    this.model = model;
+    this.options = options;
+  }
+  name = "summarization";
+  async compress(messages, targetTokens) {
+    const preserveRecent = this.options.preserveRecent ?? 6;
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const nonSystemMessages = messages.filter((m) => m.role !== "system");
+    if (nonSystemMessages.length <= preserveRecent) {
+      return messages;
+    }
+    const recentMessages = nonSystemMessages.slice(-preserveRecent);
+    const messagesToSummarize = nonSystemMessages.slice(0, -preserveRecent);
+    const summaryPrompt = this.options.summaryPrompt ?? this.buildDefaultPrompt();
+    const maxTokens = Math.min(
+      this.options.maxSummaryTokens ?? 4e3,
+      Math.floor(targetTokens * 0.3)
+    );
+    const summaryResponse = await this.model.complete({
+      messages: [
+        { role: "system", content: summaryPrompt },
+        ...messagesToSummarize
+      ],
+      maxTokens
+    });
+    return [
+      ...systemMessages,
+      {
+        role: "system",
+        content: this.wrapSummary(summaryResponse.content)
+      },
+      ...recentMessages
+    ];
+  }
+  /**
+   * 构建默认摘要提示 (借鉴 Opencode 模板)
+   */
+  buildDefaultPrompt() {
+    return `Provide a detailed prompt for continuing our conversation above.
+Focus on information that would be helpful for continuing the conversation, including what we did, what we're doing, which files we're working on, and what we're going to do next.
+The summary that you construct will be used so that another agent can read it and continue the work.
+
+When constructing the summary, try to stick to this template:
+---
+## Goal
+
+[What goal(s) is the user trying to accomplish?]
+
+## Instructions
+
+- [What important instructions did the user give you that are relevant]
+- [If there is a plan or spec, include information about it so next agent can continue using it]
+
+## Discoveries
+
+[What notable things were learned during this conversation that would be useful for the next agent to know when continuing the work]
+
+## Accomplished
+
+[What work has been completed, what work is still in progress, and what work is left?]
+
+## Relevant files / directories
+
+[Construct a structured list of relevant files that have been read, edited, or created that pertain to the task at hand. If all the files in a directory are relevant, include the path to the directory.]
+---`;
+  }
+  /**
+   * 包装摘要为 continuation 格式 (借鉴 Opencode)
+   */
+  wrapSummary(summary) {
+    return `This session is being continued from a previous conversation that ran out of context.
+The summary below covers the earlier portion of the conversation.
+
+${summary}
+
+Continue if you have next steps, or stop and ask for clarification if you are unsure how to proceed.`;
+  }
+};
+
+// src/core/context-manager.ts
+var ContextManager = class {
+  compressor;
+  reserved;
+  pruneEnabled;
+  pruneMinimum;
+  pruneProtect;
+  compressCount = 0;
+  _contextLength;
+  _maxOutputTokens;
+  constructor(model, options = {}) {
+    const contextLength = options.contextLength ?? model.capabilities?.contextLength ?? 128e3;
+    const maxOutputTokens = options.maxOutputTokens ?? model.capabilities?.maxOutputTokens ?? 32768;
+    this._contextLength = contextLength;
+    this._maxOutputTokens = maxOutputTokens;
+    this.reserved = options.reserved ?? Math.min(2e4, maxOutputTokens);
+    this.pruneEnabled = options.prune !== false;
+    this.pruneMinimum = options.pruneMinimum ?? 2e4;
+    this.pruneProtect = options.pruneProtect ?? 4e4;
+    this.compressor = options.compressor ?? new SummarizationCompressor(model);
+  }
+  /**
+   * 计算可用空间
+   *
+   * usable = contextLength - maxOutputTokens - reserved
+   */
+  get usable() {
+    return this._contextLength - this._maxOutputTokens - this.reserved;
+  }
+  /**
+   * 判断是否需要压缩
+   *
+   * 使用当前上下文大小 (contextTokens) 判断，而非累计值
+   *
+   * @param usage 会话 token 使用量
+   */
+  shouldCompress(usage) {
+    return usage.contextTokens >= this.usable;
+  }
+  /**
+   * 执行压缩
+   */
+  async compress(messages, targetTokens) {
+    const startTime = Date.now();
+    const originalCount = messages.length;
+    const target = targetTokens ?? Math.floor(this.usable * 0.6);
+    const compressedMessages = await this.compressor.compress(messages, target);
+    this.compressCount++;
+    return {
+      messages: compressedMessages,
+      stats: {
+        originalMessageCount: originalCount,
+        compressedMessageCount: compressedMessages.length,
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  /**
+   * Prune: 清理旧的工具输出
+   *
+   * 借鉴 Opencode 的 prune 策略:
+   * - 从后往前遍历消息
+   * - 保留最近 PRUNE_PROTECT tokens 的工具输出
+   * - 清理更早的工具输出
+   *
+   * @param messages 消息列表
+   * @returns 处理后的消息列表
+   */
+  prune(messages) {
+    if (!this.pruneEnabled) return messages;
+    let total = 0;
+    const toPrune = [];
+    let turns = 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (msg.role === "user") turns++;
+      if (turns < 2) continue;
+      if (msg.role === "tool") {
+        const estimate = this.estimateTokens(typeof msg.content === "string" ? msg.content : "");
+        total += estimate;
+        if (total > this.pruneProtect) {
+          toPrune.push(i);
+        }
+      }
+    }
+    if (toPrune.length > 0) {
+      const prunedTokens = toPrune.reduce((sum, idx) => {
+        const content = messages[idx].content;
+        return sum + this.estimateTokens(typeof content === "string" ? content : "");
+      }, 0);
+      if (prunedTokens >= this.pruneMinimum) {
+        return messages.map((msg, idx) => {
+          if (toPrune.includes(idx) && msg.role === "tool") {
+            return {
+              ...msg,
+              content: "[Tool output pruned to save context]"
+            };
+          }
+          return msg;
+        });
+      }
+    }
+    return messages;
+  }
+  /**
+   * 获取上下文状态
+   */
+  getStatus(usage) {
+    return {
+      used: usage.contextTokens,
+      usable: this.usable,
+      needsCompaction: usage.contextTokens >= this.usable,
+      compressCount: this.compressCount
+    };
+  }
+  /**
+   * 重置 token 使用量 (压缩后调用)
+   */
+  resetUsage() {
+    return {
+      contextTokens: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      totalTokens: 0
+    };
+  }
+  /**
+   * Token 估算 (仅用于 prune，不做压缩判断)
+   *
+   * 借鉴 Opencode: CHARS_PER_TOKEN = 4
+   */
+  estimateTokens(text) {
+    return Math.max(0, Math.round((text || "").length / 4));
+  }
+};
+
+// src/core/agent.ts
+function toMCPClientConfig(config) {
+  if (config.transport === "http") {
+    return {
+      name: config.name,
+      url: config.url,
+      headers: config.headers
+    };
+  }
+  return {
+    name: config.name,
+    command: config.command,
+    args: config.args,
+    env: config.env
+  };
+}
+var Agent = class _Agent {
+  config;
+  toolRegistry;
+  sessionManager;
+  messages = [];
+  mcpAdapter = null;
+  skillRegistry;
+  initPromise;
+  contextManager = null;
+  hookDiscoverPromise = null;
+  agentDepth = 0;
+  activeSubagentRuns = 0;
+  // Token 使用量统计
+  // contextTokens: 当前上下文大小 (用于压缩判断)
+  // inputTokens/outputTokens: 累计消耗
+  // totalTokens: 累计总消耗 (inputTokens + outputTokens)
+  sessionUsage = _Agent.createEmptySessionUsage();
+  constructor(config) {
+    this.config = {
+      maxIterations: 200,
+      streaming: true,
+      ...config
+    };
+    this.skillRegistry = createSkillRegistry({
+      cwd: config.cwd,
+      userBasePath: config.userBasePath
+    });
+    this.toolRegistry = new ToolRegistry({
+      executionPolicy: {
+        disallowedTools: this.config.disallowedTools,
+        allowedTools: this.config.allowedTools,
+        canUseTool: this.config.canUseTool
+      }
+    });
+    this.registerInitialTools();
+    const subagentEnabled = this.config.subagent?.enabled !== false;
+    if (subagentEnabled) {
+      if (this.toolRegistry.has("Agent")) {
+        this.toolRegistry.unregister("Agent");
+      }
+      this.toolRegistry.register(createAgentTool({
+        runner: (request, context) => this.runSubagent(request, context)
+      }));
+    } else if (this.toolRegistry.has("Agent")) {
+      this.toolRegistry.unregister("Agent");
+    }
+    if (config.hookManager) {
+      this.toolRegistry.setHookManager(config.hookManager);
+    } else if (config.hookConfigDir !== void 0) {
+      const hm = HookManager.create();
+      this.toolRegistry.setHookManager(hm);
+      this.hookDiscoverPromise = hm.discoverAndLoad(config.hookConfigDir);
+    }
+    this.sessionManager = new SessionManager({
+      type: config.storage?.type || "jsonl",
+      basePath: getSessionStoragePath(config.userBasePath)
+    });
+    if (config.contextManagement !== false) {
+      const cmConfig = config.contextManagement === true ? {} : config.contextManagement ?? {};
+      this.contextManager = new ContextManager(config.model, cmConfig);
+    }
+    this.initPromise = this.initializeAsync();
+  }
+  /**
+   * 注册内置 + 自定义工具，或仅 {@link AgentConfig.exclusiveTools}。
+   */
+  registerInitialTools() {
+    if (this.config.exclusiveTools !== void 0) {
+      for (const tool of this.config.exclusiveTools) {
+        if (this.toolRegistry.isDisallowed(tool.name)) {
+          continue;
+        }
+        this.toolRegistry.register(tool);
+      }
+      return;
+    }
+    const builtins = getAllBuiltinTools(this.skillRegistry, {
+      resolve: this.config.askUserQuestion
+    }).filter((t) => !this.toolRegistry.isDisallowed(t.name));
+    this.toolRegistry.registerMany(builtins);
+    for (const tool of this.config.tools ?? []) {
+      if (this.toolRegistry.isDisallowed(tool.name)) {
+        continue;
+      }
+      if (this.toolRegistry.has(tool.name)) {
+        this.toolRegistry.unregister(tool.name);
+      }
+      this.toolRegistry.register(tool);
+    }
+  }
+  /**
+   * 异步初始化（skills 和 MCP）
+   */
+  async initializeAsync() {
+    try {
+      if (this.hookDiscoverPromise) {
+        await this.hookDiscoverPromise;
+      }
+      await this.skillRegistry.initialize(
+        this.config.skillConfig,
+        this.config.skills
+      );
+      if (this.config.mcpServers && this.config.mcpServers.length > 0) {
+        this.mcpAdapter = new MCPAdapter();
+        await this.initializeMCP(this.config.mcpServers);
+      }
+    } catch (err) {
+      console.error("Failed to initialize:", err);
+    }
+  }
+  /**
+   * 等待初始化完成
+   * CLI 应在开始交互前调用此方法
+   */
+  async waitForInit() {
+    await this.initPromise;
+  }
+  /**
+   * 初始化 MCP 服务器
+   */
+  async initializeMCP(servers) {
+    if (!this.mcpAdapter) return;
+    for (const serverConfig of servers) {
+      try {
+        await this.connectMCP(serverConfig);
+      } catch (err) {
+        console.error(`Failed to connect MCP server "${serverConfig.name}":`, err);
+      }
+    }
+  }
+  annotateStreamEvent(event, iteration) {
+    return {
+      ...event,
+      streamEventId: randomUUID(),
+      ...iteration !== void 0 ? { iteration } : {},
+      sessionId: this.sessionManager.sessionId ?? void 0
+    };
+  }
+  static createEmptySessionUsage() {
+    return {
+      contextTokens: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      totalTokens: 0
+    };
+  }
+  resetSessionState() {
+    this.messages = [];
+    this.sessionUsage = this.contextManager ? this.contextManager.resetUsage() : _Agent.createEmptySessionUsage();
+  }
+  /**
+   * 构建系统提示词
+   * 处理默认提示词、替换模式、追加模式
+   */
+  buildSystemPrompt(customPrompt) {
+    const shouldIncludeEnv = typeof customPrompt === "object" ? customPrompt.includeEnvironment !== false : this.config.includeEnvironment !== false;
+    let envSection = "";
+    if (shouldIncludeEnv) {
+      const cwd = this.config.cwd || process.cwd();
+      const envInfo = getEnvironmentInfo(cwd);
+      envSection = formatEnvironmentSection(envInfo);
+    }
+    if (!customPrompt) {
+      let basePrompt = DEFAULT_SYSTEM_PROMPT;
+      basePrompt = basePrompt.replace("{{SKILL_LIST}}", this.skillRegistry.getFormattedList());
+      return basePrompt + envSection;
+    }
+    if (typeof customPrompt === "string") {
+      let basePrompt = DEFAULT_SYSTEM_PROMPT;
+      basePrompt = basePrompt.replace("{{SKILL_LIST}}", this.skillRegistry.getFormattedList());
+      return `${basePrompt}${envSection}
+
+${customPrompt}`;
+    }
+    const { content, mode = "append" } = customPrompt;
+    if (mode === "replace") {
+      return content + envSection;
+    } else {
+      let basePrompt = DEFAULT_SYSTEM_PROMPT;
+      basePrompt = basePrompt.replace("{{SKILL_LIST}}", this.skillRegistry.getFormattedList());
+      return `${basePrompt}${envSection}
+
+${content}`;
+    }
+  }
+  /**
+   * 流式执行
+   */
+  async *stream(input, options) {
+    const signal = options?.signal;
+    if (options?.sessionId) {
+      const isSwitchingSession = this.sessionManager.sessionId !== options.sessionId;
+      if (isSwitchingSession) {
+        this.resetSessionState();
+      }
+      try {
+        this.messages = await this.sessionManager.resumeSession(options.sessionId);
+      } catch {
+        this.sessionManager.createSession(options.sessionId);
+      }
+    } else if (!this.sessionManager.sessionId) {
+      this.resetSessionState();
+      this.sessionManager.createSession();
+    }
+    if (this.messages.length === 0) {
+      const systemPrompt = this.buildSystemPrompt(
+        options?.systemPrompt || this.config.systemPrompt
+      );
+      this.messages.push({
+        role: "system",
+        content: systemPrompt
+      });
+    }
+    if (this.config.memory !== false) {
+      const hasUserMessages = this.messages.some((m) => m.role === "user");
+      if (!hasUserMessages) {
+        const memoryManager = new MemoryManager(this.config.cwd, this.config.memoryConfig, this.config.userBasePath);
+        const memoryContent = memoryManager.loadMemory();
+        if (memoryContent) {
+          this.messages.push({
+            role: "system",
+            content: memoryContent
+          });
+        }
+      }
+    }
+    let processedInput = input;
+    const processed = await this.processInput(input);
+    if (processed.invoked) {
+      processedInput = processed.prompt;
+    }
+    this.messages.push({
+      role: "user",
+      content: processedInput
+    });
+    yield this.annotateStreamEvent({ type: "start", timestamp: Date.now() });
+    try {
+      const maxIterations = this.config.maxIterations || 10;
+      let totalUsage = {
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0
+      };
+      for (let iteration = 0; iteration < maxIterations; iteration++) {
+        if (signal?.aborted) {
+          yield this.annotateStreamEvent(
+            {
+              type: "end",
+              usage: totalUsage,
+              timestamp: Date.now(),
+              reason: "aborted"
+            },
+            iteration
+          );
+          return;
+        }
+        const contextEvents = await this.checkContextCompression();
+        for (const event of contextEvents) {
+          yield this.annotateStreamEvent(event, iteration);
+        }
+        const modelParams = {
+          messages: this.messages,
+          tools: this.toolRegistry.getAll(),
+          temperature: this.config.temperature,
+          maxTokens: this.config.maxTokens,
+          signal,
+          includeRawStreamEvents: options?.includeRawStreamEvents
+        };
+        const stream = this.config.model.stream(modelParams);
+        let hasToolCalls = false;
+        const toolCalls = [];
+        let assistantContent = "";
+        let thinkingContent = "";
+        let thinkingSignature;
+        const chunkProcessor = new StreamChunkProcessor({ emitTextBoundaries: true });
+        const applyStreamOut = (out) => {
+          if (out.type === "text_delta") {
+            assistantContent += out.content;
+          }
+          if (out.type === "thinking") {
+            thinkingContent += out.content;
+            if (out.signature !== void 0 && !thinkingSignature) {
+              thinkingSignature = out.signature;
+            }
+          }
+          if (out.type === "tool_call") {
+            hasToolCalls = true;
+            toolCalls.push({
+              id: out.id,
+              name: out.name,
+              arguments: out.arguments
+            });
+          }
+          if (out.type === "model_usage") {
+            const usage = out.usage;
+            if (usage.promptTokens > 0) {
+              totalUsage.promptTokens = usage.promptTokens;
+              this.sessionUsage.contextTokens = usage.promptTokens;
+              this.sessionUsage.inputTokens += usage.promptTokens;
+            }
+            totalUsage.completionTokens += usage.completionTokens;
+            totalUsage.totalTokens = totalUsage.promptTokens + totalUsage.completionTokens;
+            this.sessionUsage.outputTokens += usage.completionTokens;
+          }
+        };
+        let fatalModelError = false;
+        for await (const chunk of stream) {
+          if (signal?.aborted) {
+            for (const event of chunkProcessor.flush()) {
+              const out = this.annotateStreamEvent(event, iteration);
+              yield out;
+              applyStreamOut(out);
+            }
+            if (assistantContent) {
+              const assistantMessage2 = {
+                role: "assistant",
+                content: assistantContent
+              };
+              if (thinkingContent) {
+                assistantMessage2.content = [
+                  { type: "thinking", thinking: thinkingContent, signature: thinkingSignature || "" },
+                  { type: "text", text: assistantContent }
+                ];
+              }
+              this.messages.push(assistantMessage2);
+            }
+            this.messages.push({
+              role: "user",
+              content: "[User interrupted the response]"
+            });
+            await this.sessionManager.saveMessages(this.messages);
+            yield this.annotateStreamEvent(
+              {
+                type: "end",
+                usage: totalUsage,
+                timestamp: Date.now(),
+                reason: "aborted",
+                partialContent: assistantContent
+              },
+              iteration
+            );
+            return;
+          }
+          const events = chunkProcessor.processChunk(chunk);
+          for (const event of events) {
+            const out = this.annotateStreamEvent(event, iteration);
+            yield out;
+            applyStreamOut(out);
+            if (out.type === "end" && out.reason === "error") {
+              fatalModelError = true;
+              break;
+            }
+          }
+          if (fatalModelError) {
+            break;
+          }
+        }
+        if (fatalModelError) {
+          return;
+        }
+        for (const event of chunkProcessor.flush()) {
+          const out = this.annotateStreamEvent(event, iteration);
+          yield out;
+          applyStreamOut(out);
+        }
+        const assistantMessage = {
+          role: "assistant",
+          content: assistantContent
+        };
+        if (thinkingContent) {
+          const contentParts = [
+            {
+              type: "thinking",
+              thinking: thinkingContent,
+              signature: thinkingSignature
+            }
+          ];
+          if (assistantContent.trim()) {
+            contentParts.push({ type: "text", text: assistantContent });
+          }
+          assistantMessage.content = contentParts;
+        }
+        if (toolCalls.length > 0) {
+          assistantMessage.toolCalls = toolCalls;
+        }
+        this.messages.push(assistantMessage);
+        if (!hasToolCalls) {
+          break;
+        }
+        const toolResults = await this.executeTools(toolCalls);
+        for (const result of toolResults) {
+          if (result.isError && result.error) {
+            yield this.annotateStreamEvent(
+              {
+                type: "tool_error",
+                toolCallId: result.toolCallId,
+                error: result.error
+              },
+              iteration
+            );
+          }
+          yield this.annotateStreamEvent(
+            {
+              type: "tool_result",
+              toolCallId: result.toolCallId,
+              result: result.content
+            },
+            iteration
+          );
+          this.messages.push({
+            role: "tool",
+            toolCallId: result.toolCallId,
+            content: result.content
+          });
+        }
+      }
+      await this.sessionManager.saveMessages(this.messages);
+      yield this.annotateStreamEvent({
+        type: "session_summary",
+        usage: totalUsage,
+        iterations: Math.min(maxIterations, this.messages.length)
+      });
+      yield this.annotateStreamEvent({
+        type: "end",
+        timestamp: Date.now(),
+        reason: "complete"
+      });
+    } catch (error) {
+      if (error.name === "AbortError") {
+        yield this.annotateStreamEvent({
+          type: "end",
+          timestamp: Date.now(),
+          reason: "aborted"
+        });
+        return;
+      }
+      yield this.annotateStreamEvent({
+        type: "end",
+        timestamp: Date.now(),
+        reason: "error",
+        error
+      });
+    }
+  }
+  /**
+   * 非流式执行
+   */
+  async run(input, options) {
+    let content = "";
+    const toolCalls = [];
+    let usage;
+    let iterations = 0;
+    let streamError;
+    for await (const event of this.stream(input, options)) {
+      if (event.type === "text_delta") {
+        content += event.content;
+      }
+      if (event.type === "tool_result") {
+        const matchingCall = this.messages.filter((m) => m.role === "assistant" && m.toolCalls).flatMap((m) => m.toolCalls).find((tc) => tc.id === event.toolCallId);
+        if (matchingCall) {
+          toolCalls.push({
+            name: matchingCall.name,
+            arguments: matchingCall.arguments,
+            result: event.result
+          });
+        }
+      }
+      if (event.type === "model_usage") {
+        usage = event.usage;
+      }
+      if (event.type === "session_summary") {
+        usage = event.usage;
+        iterations = event.iterations;
+      }
+      if (event.type === "end") {
+        if (event.usage !== void 0) {
+          usage = event.usage;
+        }
+        if (event.reason === "error" && event.error) {
+          streamError = event.error;
+        }
+      }
+    }
+    if (streamError) {
+      throw streamError;
+    }
+    return {
+      content,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      usage,
+      sessionId: this.sessionManager.sessionId,
+      iterations
+    };
+  }
+  /**
+   * 注册工具
+   */
+  registerTool(tool) {
+    this.toolRegistry.register(tool);
+  }
+  /**
+   * 注册多个工具
+   */
+  registerTools(tools) {
+    for (const t of tools) {
+      this.registerTool(t);
+    }
+  }
+  /**
+   * 获取工具注册中心
+   */
+  getToolRegistry() {
+    return this.toolRegistry;
+  }
+  /**
+   * 获取会话管理器
+   */
+  getSessionManager() {
+    return this.sessionManager;
+  }
+  /**
+   * 加载 Skill
+   */
+  async loadSkill(path) {
+    await this.skillRegistry.load(path);
+  }
+  /**
+   * 获取 Skill 注册中心
+   */
+  getSkillRegistry() {
+    return this.skillRegistry;
+  }
+  /**
+   * 处理用户输入，检测并处理 skill 调用
+   * @param input 用户输入
+   * @returns 处理结果
+   */
+  async processInput(input) {
+    const invocation = this.parseSkillInvocation(input);
+    if (!invocation) {
+      return { invoked: false, prompt: input };
+    }
+    const { name, args } = invocation;
+    try {
+      const prompt = await this.invokeSkill(name, args);
+      return { invoked: true, skillName: name, prompt };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      return {
+        invoked: false,
+        prompt: `Error invoking skill "${name}": ${errorMsg}
+
+Original input: ${input}`
+      };
+    }
+  }
+  /**
+   * 调用 skill 并返回处理后的 prompt
+   * @param name Skill 名称
+   * @param args 参数字符串
+   * @returns 处理后的 prompt
+   */
+  async invokeSkill(name, args = "") {
+    const skill = this.skillRegistry.get(name);
+    if (!skill) {
+      const available = this.skillRegistry.getNames();
+      throw new Error(
+        `Skill "${name}" not found. Available skills: ${available.join(", ") || "none"}`
+      );
+    }
+    if (skill.metadata.userInvocable === false) {
+      throw new Error(`Skill "${name}" is not user-invocable`);
+    }
+    const content = await this.skillRegistry.loadFullContent(name);
+    const context = {
+      skillDir: skill.path || "",
+      sessionId: this.sessionManager.sessionId || void 0,
+      cwd: this.config.cwd
+    };
+    const processor = createSkillTemplateProcessor(context);
+    let processedContent = await processor.process(content, args);
+    if (args && !content.includes("$ARGUMENTS") && !content.includes("$0")) {
+      processedContent += `
+
+ARGUMENTS: ${args}`;
+    }
+    return processedContent;
+  }
+  /**
+   * 解析 skill 调用格式
+   * 格式: /skill-name [args]
+   * @param input 用户输入
+   * @returns 解析结果或 null
+   */
+  parseSkillInvocation(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/")) {
+      return null;
+    }
+    const match = trimmed.match(/^\/([^\s\/]+)(?:\s+(.*))?$/);
+    if (!match) {
+      return null;
+    }
+    const name = match[1];
+    const args = match[2] || "";
+    if (!this.skillRegistry.has(name)) {
+      return null;
+    }
+    return { name, args };
+  }
+  /**
+   * 连接 MCP 服务器
+   */
+  async connectMCP(config) {
+    if (!this.mcpAdapter) {
+      this.mcpAdapter = new MCPAdapter();
+    }
+    await this.mcpAdapter.addServer(toMCPClientConfig(config));
+    const mcpTools = this.mcpAdapter.getToolDefinitions();
+    for (const tool of mcpTools) {
+      if (!tool.name.startsWith(`mcp_${config.name}__`)) {
+        continue;
+      }
+      if (this.toolRegistry.isDisallowed(tool.name)) {
+        continue;
+      }
+      this.toolRegistry.register(tool);
+    }
+  }
+  /**
+   * 断开指定 MCP 服务器
+   */
+  async disconnectMCP(name) {
+    if (!this.mcpAdapter) return;
+    const tools = this.toolRegistry.getAll();
+    for (const tool of tools) {
+      if (tool.name.startsWith(`mcp_${name}__`)) {
+        this.toolRegistry.unregister(tool.name);
+      }
+    }
+    await this.mcpAdapter.removeServer(name);
+  }
+  /**
+   * 断开所有 MCP 服务器
+   */
+  async disconnectAllMCP() {
+    if (!this.mcpAdapter) return;
+    const tools = this.toolRegistry.getAll();
+    for (const tool of tools) {
+      if (tool.name.startsWith("mcp_") && tool.name.includes("__")) {
+        this.toolRegistry.unregister(tool.name);
+      }
+    }
+    await this.mcpAdapter.disconnectAll();
+    this.mcpAdapter = null;
+  }
+  /**
+   * 获取 MCP 适配器
+   */
+  getMCPAdapter() {
+    return this.mcpAdapter;
+  }
+  /**
+   * 销毁 Agent，清理资源
+   */
+  async destroy() {
+    await this.disconnectAllMCP();
+    this.messages = [];
+  }
+  /**
+   * 获取消息历史
+   */
+  getMessages() {
+    return [...this.messages];
+  }
+  /**
+   * 清空消息历史
+   */
+  clearMessages() {
+    this.resetSessionState();
+  }
+  /**
+   * 设置系统提示 (运行时替换)
+   */
+  setSystemPrompt(prompt) {
+    this.messages = this.messages.filter((m) => m.role !== "system");
+    const systemPrompt = this.buildSystemPrompt(prompt);
+    if (this.messages.length > 0) {
+      this.messages.unshift({
+        role: "system",
+        content: systemPrompt
+      });
+    }
+  }
+  /**
+   * 追加系统提示内容
+   */
+  appendSystemPrompt(additionalContent) {
+    const systemMessageIndex = this.messages.findIndex((m) => m.role === "system");
+    if (systemMessageIndex >= 0) {
+      this.messages[systemMessageIndex].content += `
+
+${additionalContent}`;
+    } else {
+      const systemPrompt = this.buildSystemPrompt(additionalContent);
+      this.messages.unshift({
+        role: "system",
+        content: systemPrompt
+      });
+    }
+  }
+  /**
+   * 获取当前系统提示内容
+   */
+  getSystemPrompt() {
+    const systemMessage = this.messages.find((m) => m.role === "system");
+    if (!systemMessage) return void 0;
+    return typeof systemMessage.content === "string" ? systemMessage.content : void 0;
+  }
+  /**
+   * 手动触发上下文压缩
+   */
+  async compressContext() {
+    if (!this.contextManager) {
+      throw new Error("Context management is disabled");
+    }
+    const result = await this.contextManager.compress(this.messages);
+    this.messages = result.messages;
+    this.sessionUsage = this.contextManager.resetUsage();
+    await this.sessionManager.saveMessages(this.messages);
+    return {
+      messageCount: this.messages.length,
+      stats: result.stats
+    };
+  }
+  /**
+   * 获取上下文状态
+   */
+  getContextStatus() {
+    if (!this.contextManager) {
+      return null;
+    }
+    return this.contextManager.getStatus(this.sessionUsage);
+  }
+  /**
+   * 获取会话累计 Token 使用量
+   */
+  getSessionUsage() {
+    return {
+      ...this.sessionUsage,
+      totalTokens: this.sessionUsage.inputTokens + this.sessionUsage.outputTokens
+    };
+  }
+  /**
+   * 检查并执行上下文压缩
+   * @returns 压缩事件数组（可能为空）
+   */
+  async checkContextCompression() {
+    if (!this.contextManager) {
+      return [];
+    }
+    this.messages = this.contextManager.prune(this.messages);
+    if (!this.contextManager.shouldCompress(this.sessionUsage)) {
+      return [];
+    }
+    const result = await this.contextManager.compress(this.messages);
+    this.messages = result.messages;
+    this.sessionUsage = this.contextManager.resetUsage();
+    return [
+      {
+        type: "context_compressed",
+        stats: result.stats
+      }
+    ];
+  }
+  getSubagentConfig() {
+    return {
+      enabled: this.config.subagent?.enabled !== false,
+      maxDepth: this.config.subagent?.maxDepth ?? 1,
+      maxParallel: this.config.subagent?.maxParallel ?? 5,
+      timeoutMs: this.config.subagent?.timeoutMs ?? 12e4,
+      allowDangerousTools: this.config.subagent?.allowDangerousTools ?? false,
+      defaultAllowedTools: this.config.subagent?.defaultAllowedTools
+    };
+  }
+  resolveSubagentTools(request) {
+    const subagentConfig = this.getSubagentConfig();
+    const parentTools = this.toolRegistry.getAll();
+    const byName = new Map(parentTools.map((tool) => [tool.name, tool]));
+    const requestedNames = request.allowed_tools ?? subagentConfig.defaultAllowedTools;
+    let selected = requestedNames ? requestedNames.map((name) => byName.get(name)).filter((tool) => tool !== void 0) : parentTools.filter((tool) => !tool.isDangerous);
+    selected = selected.filter((tool) => tool.name !== "Agent");
+    selected = selected.filter((tool) => tool.name !== "AskUserQuestion");
+    if (!subagentConfig.allowDangerousTools) {
+      const requestedDangerous = request.allowed_tools?.some((name) => byName.get(name)?.isDangerous);
+      if (requestedDangerous) {
+        return {
+          error: "Subagent dangerous tools are disabled by configuration"
+        };
+      }
+      selected = selected.filter((tool) => !tool.isDangerous);
+    }
+    if (selected.length === 0) {
+      return { error: "No tools available for subagent after filtering" };
+    }
+    return { tools: selected };
+  }
+  async runSubagent(request, context) {
+    const subagentConfig = this.getSubagentConfig();
+    const currentDepth = context?.agentDepth ?? this.agentDepth;
+    if (!subagentConfig.enabled) {
+      return { content: "Subagent is disabled by configuration", isError: true };
+    }
+    if (currentDepth >= subagentConfig.maxDepth) {
+      return { content: "Subagent cannot spawn subagents", isError: true };
+    }
+    if (this.activeSubagentRuns >= subagentConfig.maxParallel) {
+      return { content: "Subagent concurrency limit reached", isError: true };
+    }
+    const normalizedType = request.subagent_type ?? "general-purpose";
+    const requestedTimeout = request.timeout_ms ?? subagentConfig.timeoutMs;
+    const timeoutMs = Math.min(requestedTimeout, subagentConfig.timeoutMs);
+    const maxIterations = Math.max(1, request.max_iterations ?? this.config.maxIterations ?? 50);
+    const resolved = this.resolveSubagentTools(request);
+    if (!resolved.tools) {
+      return {
+        content: resolved.error ?? "Unable to resolve subagent tools",
+        isError: true
+      };
+    }
+    const childConfig = {
+      ...this.config,
+      exclusiveTools: resolved.tools,
+      tools: void 0,
+      mcpServers: void 0,
+      maxIterations,
+      subagent: {
+        ...this.config.subagent,
+        enabled: false
+      }
+    };
+    const child = new _Agent(childConfig);
+    child.agentDepth = currentDepth + 1;
+    const startedAt = Date.now();
+    this.activeSubagentRuns += 1;
+    try {
+      await child.waitForInit();
+      const runPromise = child.run(request.prompt, {
+        systemPrompt: request.system_prompt
+      });
+      const timeoutPromise = new Promise((_, reject) => {
+        const timer = setTimeout(() => {
+          reject(new Error(`Subagent timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        runPromise.finally(() => clearTimeout(timer)).catch(() => {
+        });
+      });
+      const result = await Promise.race([runPromise, timeoutPromise]);
+      return {
+        content: result.content,
+        metadata: {
+          sessionId: result.sessionId,
+          subagentType: normalizedType,
+          durationMs: Date.now() - startedAt,
+          usage: result.usage,
+          toolNames: resolved.tools.map((tool) => tool.name),
+          description: request.description
+        }
+      };
+    } catch (error) {
+      return {
+        content: error instanceof Error ? error.message : String(error),
+        isError: true,
+        metadata: {
+          subagentType: normalizedType,
+          durationMs: Date.now() - startedAt,
+          description: request.description,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      };
+    } finally {
+      this.activeSubagentRuns -= 1;
+      await child.destroy();
+    }
+  }
+  /**
+   * 获取默认系统提示词
+   */
+  static getDefaultSystemPrompt() {
+    return DEFAULT_SYSTEM_PROMPT;
+  }
+  /**
+   * 执行工具调用
+   */
+  async executeTools(toolCalls) {
+    const results = await Promise.all(
+      toolCalls.map(async (tc) => {
+        const result = await this.toolRegistry.execute(tc.name, tc.arguments, {
+          toolCallId: tc.id,
+          projectDir: this.config.cwd || process.cwd(),
+          agentDepth: this.agentDepth
+        });
+        const isError = Boolean(result.isError);
+        return {
+          toolCallId: tc.id,
+          content: isError ? `Error: ${result.content}` : result.content,
+          isError,
+          error: isError ? new Error(result.content) : void 0
+        };
+      })
+    );
+    return results;
+  }
+};
+function createAgent(config) {
+  return new Agent(config);
+}
+function expandEnvVars(value) {
+  let result = value.replace(/\$\{([^}]+)\}/g, (_, varName) => {
+    return process.env[varName] || "";
+  });
+  result = result.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, varName) => {
+    return process.env[varName] || "";
+  });
+  return result;
+}
+function expandEnvVarsInObject(obj) {
+  if (typeof obj === "string") {
+    return expandEnvVars(obj);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => expandEnvVarsInObject(item));
+  }
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = expandEnvVarsInObject(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function transformConfig(config) {
+  const servers = [];
+  for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+    const transport = serverConfig.url ? "http" : "stdio";
+    const server = {
+      name,
+      transport,
+      ...transport === "stdio" ? {
+        command: serverConfig.command,
+        args: serverConfig.args,
+        env: serverConfig.env
+      } : {
+        url: serverConfig.url,
+        headers: serverConfig.headers
+      }
+    };
+    servers.push(server);
+  }
+  return servers;
+}
+function findConfigFiles(startDir = process.cwd(), userBasePath) {
+  const paths = [];
+  const base = userBasePath || homedir();
+  const userConfig = join(base, ".claude", "mcp_config.json");
+  if (existsSync(userConfig)) {
+    paths.push(userConfig);
+  }
+  const workspaceConfig = join(startDir, ".claude", "mcp_config.json");
+  if (existsSync(workspaceConfig)) {
+    paths.push(workspaceConfig);
+  }
+  return paths;
+}
+function loadSingleConfig(filePath) {
+  const content = readFileSync(filePath, "utf-8");
+  const rawConfig = JSON.parse(content);
+  const expandedConfig = expandEnvVarsInObject(rawConfig);
+  return transformConfig(expandedConfig);
+}
+function loadMCPConfig(configPath, startDir = process.cwd(), userBasePath) {
+  if (configPath) {
+    if (!existsSync(configPath)) {
+      return { servers: [] };
+    }
+    try {
+      const servers = loadSingleConfig(configPath);
+      return { servers, configPath };
+    } catch (error) {
+      console.error(`Failed to load MCP config from ${configPath}:`, error);
+      return { servers: [] };
+    }
+  }
+  const configPaths = findConfigFiles(startDir, userBasePath);
+  if (configPaths.length === 0) {
+    return { servers: [] };
+  }
+  const mergedServers = /* @__PURE__ */ new Map();
+  for (const path of configPaths) {
+    try {
+      const servers = loadSingleConfig(path);
+      for (const server of servers) {
+        mergedServers.set(server.name, server);
+      }
+    } catch (error) {
+      console.error(`Failed to load MCP config from ${path}:`, error);
+    }
+  }
+  return {
+    servers: Array.from(mergedServers.values()),
+    configPath: configPaths[configPaths.length - 1],
+    // 主配置（工作目录）
+    configPaths
+  };
+}
+function validateMCPConfig(config) {
+  const errors = [];
+  if (!config.mcpServers || typeof config.mcpServers !== "object") {
+    errors.push("mcpServers must be an object");
+    return errors;
+  }
+  for (const [name, server] of Object.entries(config.mcpServers)) {
+    if (!server.command && !server.url) {
+      errors.push(`Server "${name}": must have either "command" or "url"`);
+    }
+    if (server.command && server.url) {
+      errors.push(`Server "${name}": cannot have both "command" and "url"`);
+    }
+  }
+  return errors;
+}
+
+export { Agent, DEFAULT_SYSTEM_PROMPT, JsonlStorage, MCPAdapter, MCPClient, MemoryManager, MemoryStorage, SessionManager, SkillLoader, SkillRegistry, StreamChunkProcessor, createAgent, createJsonlStorage, createMCPAdapter, createMCPClient, createMemoryStorage, createSessionManager, createSkillLoader, createSkillRegistry, createStorage, getLatestSessionId, getSessionStoragePath, loadMCPConfig, parseSkillMd, validateMCPConfig };
+//# sourceMappingURL=chunk-Q3SOMX26.js.map
+//# sourceMappingURL=chunk-Q3SOMX26.js.map