@n0ts123/mcplink-core 0.0.1

package/dist/index.js

@@ -0,0 +1,1410 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { generateText, streamText } from 'ai';
+import { z } from 'zod';
+
+// src/MCPManager.ts
+var MCPManager = class {
+  servers = /* @__PURE__ */ new Map();
+  /**
+   * 添加 MCP 服务器配置
+   */
+  addServer(id, config) {
+    if (this.servers.has(id)) {
+      throw new Error(`MCP server "${id}" already exists`);
+    }
+    const client = new Client({ name: "mcplink", version: "0.0.1" }, { capabilities: {} });
+    let transport;
+    if (config.type === "sse") {
+      const sseConfig = config;
+      transport = new SSEClientTransport(new URL(sseConfig.url));
+    } else {
+      const stdioConfig = config;
+      const processEnv = {};
+      for (const [key, value] of Object.entries(process.env)) {
+        if (value !== void 0) {
+          processEnv[key] = value;
+        }
+      }
+      const mergedEnv = {
+        ...processEnv,
+        ...stdioConfig.env
+      };
+      const isWindows = process.platform === "win32";
+      let command = stdioConfig.command;
+      let args = stdioConfig.args || [];
+      if (isWindows) {
+        const windowsCommands = ["npx", "npm", "node", "pnpm", "yarn", "bunx"];
+        if (windowsCommands.includes(command.toLowerCase())) {
+          args = ["/c", command, ...args];
+          command = "cmd";
+        }
+      }
+      transport = new StdioClientTransport({
+        command,
+        args,
+        env: mergedEnv
+      });
+    }
+    this.servers.set(id, {
+      id,
+      config,
+      client,
+      transport,
+      tools: [],
+      status: "stopped"
+    });
+  }
+  /**
+   * 启动 MCP 服务器
+   */
+  async startServer(id) {
+    const server = this.servers.get(id);
+    if (!server) {
+      throw new Error(`MCP server "${id}" not found`);
+    }
+    if (server.status === "running") {
+      return;
+    }
+    server.status = "starting";
+    server.error = void 0;
+    const config = server.config;
+    if (config.type === "stdio") {
+      const stdioConfig = config;
+      const isWindows = process.platform === "win32";
+      const windowsCommands = ["npx", "npm", "node", "pnpm", "yarn", "bunx"];
+      let displayCmd = stdioConfig.command;
+      let displayArgs = stdioConfig.args || [];
+      if (isWindows && windowsCommands.includes(stdioConfig.command.toLowerCase())) {
+        displayCmd = "cmd";
+        displayArgs = ["/c", stdioConfig.command, ...displayArgs];
+      }
+      console.log(`
+\u{1F527} [MCP] \u6B63\u5728\u542F\u52A8\u670D\u52A1\u5668 "${id}"...`);
+      console.log(`   \u547D\u4EE4: ${displayCmd} ${displayArgs.join(" ")}`);
+      if (stdioConfig.env && Object.keys(stdioConfig.env).length > 0) {
+        console.log(`   \u73AF\u5883\u53D8\u91CF: ${Object.keys(stdioConfig.env).join(", ")}`);
+      }
+    } else {
+      const sseConfig = config;
+      console.log(`
+\u{1F527} [MCP] \u6B63\u5728\u8FDE\u63A5 SSE \u670D\u52A1\u5668 "${id}"...`);
+      console.log(`   URL: ${sseConfig.url}`);
+    }
+    try {
+      await server.client.connect(server.transport);
+      const toolsResult = await server.client.listTools();
+      server.tools = toolsResult.tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description || "",
+        inputSchema: tool.inputSchema
+      }));
+      server.status = "running";
+      console.log(`\u2705 [MCP] \u670D\u52A1\u5668 "${id}" \u542F\u52A8\u6210\u529F\uFF0C\u53D1\u73B0 ${server.tools.length} \u4E2A\u5DE5\u5177`);
+      if (server.tools.length > 0) {
+        console.log(`   \u5DE5\u5177: ${server.tools.map((t) => t.name).join(", ")}`);
+      }
+    } catch (error) {
+      server.status = "error";
+      let errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("Connection closed")) {
+        if (config.type === "stdio") {
+          const stdioConfig = config;
+          errorMessage = `MCP \u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25: \u8FDB\u7A0B\u7ACB\u5373\u9000\u51FA\u3002
+\u547D\u4EE4: ${stdioConfig.command} ${(stdioConfig.args || []).join(" ")}
+\u53EF\u80FD\u539F\u56E0:
+1. \u547D\u4EE4 "${stdioConfig.command}" \u4E0D\u5B58\u5728\u6216\u4E0D\u5728 PATH \u4E2D
+2. \u5982\u679C\u4F7F\u7528 Docker\uFF0C\u8BF7\u786E\u4FDD Docker \u6B63\u5728\u8FD0\u884C
+3. \u68C0\u67E5\u73AF\u5883\u53D8\u91CF\u662F\u5426\u6B63\u786E\u914D\u7F6E
+4. \u5C1D\u8BD5\u5728\u7EC8\u7AEF\u624B\u52A8\u8FD0\u884C\u547D\u4EE4\u67E5\u770B\u5177\u4F53\u9519\u8BEF`;
+        }
+      }
+      console.error(`\u274C [MCP] \u670D\u52A1\u5668 "${id}" \u542F\u52A8\u5931\u8D25:`);
+      console.error(`   ${errorMessage.split("\n").join("\n   ")}`);
+      server.error = errorMessage;
+      throw new Error(errorMessage);
+    }
+  }
+  /**
+   * 停止 MCP 服务器
+   */
+  async stopServer(id) {
+    const server = this.servers.get(id);
+    if (!server) {
+      throw new Error(`MCP server "${id}" not found`);
+    }
+    if (server.status === "stopped") {
+      return;
+    }
+    console.log(`\u{1F527} [MCP] \u6B63\u5728\u505C\u6B62\u670D\u52A1\u5668 "${id}"...`);
+    try {
+      await server.client.close();
+      console.log(`\u2705 [MCP] \u670D\u52A1\u5668 "${id}" \u5DF2\u505C\u6B62`);
+    } catch (error) {
+      console.error(`\u26A0\uFE0F [MCP] \u505C\u6B62\u670D\u52A1\u5668 "${id}" \u65F6\u51FA\u9519:`, error);
+    } finally {
+      server.status = "stopped";
+      server.tools = [];
+    }
+  }
+  /**
+   * 启动所有已配置的服务器
+   */
+  async startAll() {
+    const startPromises = Array.from(this.servers.keys()).map(
+      (id) => this.startServer(id).catch((error) => {
+        console.error(`Failed to start MCP server "${id}":`, error);
+      })
+    );
+    await Promise.all(startPromises);
+  }
+  /**
+   * 停止所有服务器
+   */
+  async stopAll() {
+    const stopPromises = Array.from(this.servers.keys()).map(
+      (id) => this.stopServer(id).catch((error) => {
+        console.error(`Failed to stop MCP server "${id}":`, error);
+      })
+    );
+    await Promise.all(stopPromises);
+  }
+  /**
+   * 获取所有可用的工具
+   */
+  getAllTools() {
+    const tools = [];
+    for (const server of this.servers.values()) {
+      if (server.status === "running") {
+        tools.push(...server.tools);
+      }
+    }
+    return tools;
+  }
+  /**
+   * 调用工具
+   */
+  async callTool(toolName, args) {
+    for (const server of this.servers.values()) {
+      if (server.status !== "running") continue;
+      const tool = server.tools.find((t) => t.name === toolName);
+      if (tool) {
+        const result = await server.client.callTool({
+          name: toolName,
+          arguments: args
+        });
+        if (result.content && Array.isArray(result.content)) {
+          const textContents = result.content.filter((c) => c.type === "text").map((c) => c.text);
+          if (textContents.length > 0) {
+            const textResult = textContents.join("\n");
+            if (result.isError) {
+              throw new Error(textResult || "\u5DE5\u5177\u6267\u884C\u5931\u8D25");
+            }
+            return textResult;
+          }
+        }
+        if (result.isError) {
+          const errorContent = result.content;
+          throw new Error(
+            typeof errorContent === "string" ? errorContent : JSON.stringify(errorContent) || "\u5DE5\u5177\u6267\u884C\u5931\u8D25"
+          );
+        }
+        return result.content;
+      }
+    }
+    throw new Error(`Tool "${toolName}" not found in any running MCP server`);
+  }
+  /**
+   * 获取所有服务器状态
+   */
+  getServerStatuses() {
+    return Array.from(this.servers.values()).map((server) => ({
+      id: server.id,
+      name: server.id,
+      config: server.config,
+      status: server.status,
+      tools: server.tools,
+      error: server.error
+    }));
+  }
+  /**
+   * 移除服务器
+   */
+  async removeServer(id) {
+    await this.stopServer(id);
+    this.servers.delete(id);
+  }
+};
+
+// src/types.ts
+var MCPLinkEventType = /* @__PURE__ */ ((MCPLinkEventType2) => {
+  MCPLinkEventType2["THINKING_START"] = "thinking_start";
+  MCPLinkEventType2["THINKING_DELTA"] = "thinking_delta";
+  MCPLinkEventType2["THINKING_END"] = "thinking_end";
+  MCPLinkEventType2["THINKING_CONTENT"] = "thinking_content";
+  MCPLinkEventType2["TEXT_START"] = "text_start";
+  MCPLinkEventType2["TEXT_DELTA"] = "text_delta";
+  MCPLinkEventType2["TEXT_END"] = "text_end";
+  MCPLinkEventType2["TOOL_CALL_START"] = "tool_call_start";
+  MCPLinkEventType2["TOOL_CALL_DELTA"] = "tool_call_delta";
+  MCPLinkEventType2["TOOL_CALL_END"] = "tool_call_end";
+  MCPLinkEventType2["TOOL_EXECUTING"] = "tool_executing";
+  MCPLinkEventType2["TOOL_RESULT"] = "tool_result";
+  MCPLinkEventType2["ITERATION_START"] = "iteration_start";
+  MCPLinkEventType2["ITERATION_END"] = "iteration_end";
+  MCPLinkEventType2["COMPLETE"] = "complete";
+  MCPLinkEventType2["ERROR"] = "error";
+  MCPLinkEventType2["TODO_START"] = "todo_start";
+  MCPLinkEventType2["TODO_ITEM_ADD"] = "todo_item_add";
+  MCPLinkEventType2["TODO_ITEM_UPDATE"] = "todo_item_update";
+  MCPLinkEventType2["TODO_END"] = "todo_end";
+  return MCPLinkEventType2;
+})(MCPLinkEventType || {});
+
+// src/Agent.ts
+var DEFAULT_SYSTEM_PROMPT = `\u4F60\u662F\u4E00\u4E2A\u667A\u80FD\u52A9\u624B\uFF0C\u8BF7\u4F7F\u7528\u4E2D\u6587\u56DE\u590D\u3002`;
+var Agent = class {
+  model;
+  mcpManager;
+  systemPrompt;
+  maxIterations;
+  constructor(model, mcpManager, options = {}) {
+    this.model = model;
+    this.mcpManager = mcpManager;
+    this.systemPrompt = options.systemPrompt || DEFAULT_SYSTEM_PROMPT;
+    this.maxIterations = options.maxIterations || 10;
+  }
+  /**
+   * 将 MCP 工具转换为 Vercel AI SDK 格式
+   */
+  convertMCPToolsToAITools(mcpTools) {
+    const tools = {};
+    for (const mcpTool of mcpTools) {
+      const zodSchema = this.jsonSchemaToZod(mcpTool.inputSchema);
+      tools[mcpTool.name] = {
+        description: mcpTool.description,
+        parameters: zodSchema
+      };
+    }
+    return tools;
+  }
+  /**
+   * 简单的 JSON Schema 到 Zod 转换
+   */
+  jsonSchemaToZod(schema) {
+    if (!schema.properties) {
+      return z.object({});
+    }
+    const shape = {};
+    const required = schema.required || [];
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      const propSchema = prop;
+      let zodType;
+      switch (propSchema.type) {
+        case "string":
+          zodType = z.string();
+          break;
+        case "number":
+          zodType = z.number();
+          break;
+        case "integer":
+          zodType = z.number().int();
+          break;
+        case "boolean":
+          zodType = z.boolean();
+          break;
+        case "array":
+          if (propSchema.items?.type === "string") {
+            zodType = z.array(z.string());
+          } else if (propSchema.items?.type === "number") {
+            zodType = z.array(z.number());
+          } else {
+            zodType = z.array(z.unknown());
+          }
+          break;
+        default:
+          zodType = z.unknown();
+      }
+      if (propSchema.description) {
+        zodType = zodType.describe(propSchema.description);
+      }
+      if (!required.includes(key)) {
+        zodType = zodType.optional();
+      }
+      shape[key] = zodType;
+    }
+    return z.object(shape);
+  }
+  /**
+   * 执行对话
+   */
+  async chat(userMessage, callbacks) {
+    const startTime = Date.now();
+    const toolCallRecords = [];
+    let totalPromptTokens = 0;
+    let totalCompletionTokens = 0;
+    const messages = [
+      { role: "system", content: this.systemPrompt },
+      { role: "user", content: userMessage }
+    ];
+    const mcpTools = this.mcpManager.getAllTools();
+    const tools = this.convertMCPToolsToAITools(mcpTools);
+    let iteration = 0;
+    let finalContent = "";
+    while (iteration < this.maxIterations) {
+      iteration++;
+      callbacks?.onIterationStart?.(iteration);
+      const response = await generateText({
+        model: this.model,
+        messages,
+        tools: Object.keys(tools).length > 0 ? tools : void 0,
+        maxSteps: 1
+        // 每次只执行一步，方便我们控制流程
+      });
+      if (response.usage) {
+        totalPromptTokens += response.usage.promptTokens;
+        totalCompletionTokens += response.usage.completionTokens;
+      }
+      const toolCalls = response.toolCalls || [];
+      if (toolCalls.length === 0) {
+        finalContent = response.text || "";
+        callbacks?.onTextDelta?.(finalContent);
+        callbacks?.onIterationEnd?.(iteration);
+        break;
+      }
+      const toolResults = [];
+      for (const toolCall of toolCalls) {
+        const toolName = toolCall.toolName;
+        const toolArgs = toolCall.args;
+        const toolCallId = toolCall.toolCallId;
+        callbacks?.onToolCallStart?.(toolName, toolArgs);
+        const toolStartTime = Date.now();
+        let result;
+        let isError = false;
+        try {
+          result = await this.mcpManager.callTool(toolName, toolArgs);
+        } catch (error) {
+          result = error instanceof Error ? error.message : String(error);
+          isError = true;
+        }
+        const duration2 = Date.now() - toolStartTime;
+        callbacks?.onToolResult?.(toolName, result, duration2);
+        toolResults.push({
+          toolCallId,
+          toolName,
+          result,
+          isError,
+          duration: duration2
+        });
+        toolCallRecords.push({
+          name: toolName,
+          arguments: toolArgs,
+          result,
+          duration: duration2
+        });
+      }
+      messages.push({
+        role: "assistant",
+        content: [
+          { type: "text", text: response.text || "" },
+          ...toolCalls.map((tc) => ({
+            type: "tool-call",
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            args: tc.args
+          }))
+        ]
+      });
+      for (const tr of toolResults) {
+        messages.push({
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: tr.toolCallId,
+              toolName: tr.toolName,
+              result: tr.result
+            }
+          ]
+        });
+      }
+      callbacks?.onIterationEnd?.(iteration);
+    }
+    const duration = Date.now() - startTime;
+    return {
+      content: finalContent,
+      toolCalls: toolCallRecords,
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+      })),
+      usage: {
+        promptTokens: totalPromptTokens,
+        completionTokens: totalCompletionTokens,
+        totalTokens: totalPromptTokens + totalCompletionTokens
+      },
+      iterations: iteration,
+      duration
+    };
+  }
+  /**
+   * 流式对话 - 返回事件生成器
+   * @param userMessage 用户消息
+   * @param options 可选参数
+   * @param options.allowedTools 允许使用的工具名称列表，为空或不传则使用所有工具
+   * @param options.history 历史消息列表
+   */
+  async *chatStream(userMessage, options) {
+    const startTime = Date.now();
+    const messages = [{ role: "system", content: this.systemPrompt }];
+    if (options?.history && options.history.length > 0) {
+      for (const msg of options.history) {
+        messages.push({
+          role: msg.role,
+          content: msg.content
+        });
+      }
+    }
+    messages.push({ role: "user", content: userMessage });
+    let mcpTools = this.mcpManager.getAllTools();
+    if (options?.allowedTools && options.allowedTools.length > 0) {
+      mcpTools = mcpTools.filter((tool) => options.allowedTools.includes(tool.name));
+    }
+    const tools = this.convertMCPToolsToAITools(mcpTools);
+    const hasTools = Object.keys(tools).length > 0;
+    let iteration = 0;
+    while (iteration < this.maxIterations) {
+      iteration++;
+      yield {
+        type: "iteration_start" /* ITERATION_START */,
+        timestamp: Date.now(),
+        data: { iteration, maxIterations: this.maxIterations }
+      };
+      const stream = streamText({
+        model: this.model,
+        messages,
+        tools: hasTools ? tools : void 0,
+        maxSteps: 1
+      });
+      let fullText = "";
+      let reasoningText = "";
+      const toolCalls = [];
+      let currentToolCall = null;
+      let hasStartedText = false;
+      let hasStartedReasoning = false;
+      const sentToolCallStarts = /* @__PURE__ */ new Set();
+      let isInsideThinkTag = false;
+      let textBuffer = "";
+      for await (const chunk of stream.fullStream) {
+        switch (chunk.type) {
+          case "reasoning":
+            if (!hasStartedReasoning) {
+              hasStartedReasoning = true;
+              yield {
+                type: "thinking_start" /* THINKING_START */,
+                timestamp: Date.now(),
+                data: {}
+              };
+            }
+            reasoningText += chunk.textDelta;
+            yield {
+              type: "thinking_delta" /* THINKING_DELTA */,
+              timestamp: Date.now(),
+              data: { content: chunk.textDelta }
+            };
+            break;
+          case "text-delta":
+            const delta = chunk.textDelta;
+            textBuffer += delta;
+            if (!isInsideThinkTag) {
+              const thinkStartMatch = textBuffer.match(/<think>/i);
+              if (thinkStartMatch) {
+                const beforeThink = textBuffer.substring(0, thinkStartMatch.index);
+                if (beforeThink.trim()) {
+                  if (!hasStartedText) {
+                    hasStartedText = true;
+                    yield {
+                      type: "text_start" /* TEXT_START */,
+                      timestamp: Date.now(),
+                      data: {}
+                    };
+                  }
+                  fullText += beforeThink;
+                  yield {
+                    type: "text_delta" /* TEXT_DELTA */,
+                    timestamp: Date.now(),
+                    data: { content: beforeThink }
+                  };
+                }
+                isInsideThinkTag = true;
+                if (!hasStartedReasoning) {
+                  hasStartedReasoning = true;
+                  yield {
+                    type: "thinking_start" /* THINKING_START */,
+                    timestamp: Date.now(),
+                    data: {}
+                  };
+                }
+                textBuffer = textBuffer.substring(thinkStartMatch.index + 7);
+              } else if (!textBuffer.includes("<")) {
+                if (hasStartedReasoning && !hasStartedText) {
+                  yield {
+                    type: "thinking_end" /* THINKING_END */,
+                    timestamp: Date.now(),
+                    data: {}
+                  };
+                }
+                if (!hasStartedText) {
+                  hasStartedText = true;
+                  yield {
+                    type: "text_start" /* TEXT_START */,
+                    timestamp: Date.now(),
+                    data: {}
+                  };
+                }
+                fullText += textBuffer;
+                yield {
+                  type: "text_delta" /* TEXT_DELTA */,
+                  timestamp: Date.now(),
+                  data: { content: textBuffer }
+                };
+                textBuffer = "";
+              }
+            } else {
+              const thinkEndMatch = textBuffer.match(/<\/think>/i);
+              if (thinkEndMatch) {
+                const thinkContent = textBuffer.substring(0, thinkEndMatch.index);
+                if (thinkContent) {
+                  reasoningText += thinkContent;
+                  yield {
+                    type: "thinking_delta" /* THINKING_DELTA */,
+                    timestamp: Date.now(),
+                    data: { content: thinkContent }
+                  };
+                }
+                yield {
+                  type: "thinking_end" /* THINKING_END */,
+                  timestamp: Date.now(),
+                  data: {}
+                };
+                isInsideThinkTag = false;
+                textBuffer = textBuffer.substring(thinkEndMatch.index + 8);
+              } else if (!textBuffer.includes("<")) {
+                reasoningText += textBuffer;
+                yield {
+                  type: "thinking_delta" /* THINKING_DELTA */,
+                  timestamp: Date.now(),
+                  data: { content: textBuffer }
+                };
+                textBuffer = "";
+              }
+            }
+            break;
+          case "tool-call":
+            if (!sentToolCallStarts.has(chunk.toolCallId)) {
+              yield {
+                type: "tool_call_start" /* TOOL_CALL_START */,
+                timestamp: Date.now(),
+                data: {
+                  toolName: chunk.toolName,
+                  toolCallId: chunk.toolCallId,
+                  toolArgs: chunk.args
+                }
+              };
+              sentToolCallStarts.add(chunk.toolCallId);
+            }
+            toolCalls.push({
+              toolCallId: chunk.toolCallId,
+              toolName: chunk.toolName,
+              args: chunk.args
+            });
+            break;
+          case "tool-call-streaming-start":
+            currentToolCall = {
+              toolCallId: chunk.toolCallId,
+              toolName: chunk.toolName,
+              argsText: ""
+            };
+            if (!sentToolCallStarts.has(chunk.toolCallId)) {
+              yield {
+                type: "tool_call_start" /* TOOL_CALL_START */,
+                timestamp: Date.now(),
+                data: {
+                  toolName: chunk.toolName,
+                  toolCallId: chunk.toolCallId
+                }
+              };
+              sentToolCallStarts.add(chunk.toolCallId);
+            }
+            break;
+          case "tool-call-delta":
+            if (currentToolCall) {
+              currentToolCall.argsText += chunk.argsTextDelta;
+              yield {
+                type: "tool_call_delta" /* TOOL_CALL_DELTA */,
+                timestamp: Date.now(),
+                data: {
+                  toolCallId: currentToolCall.toolCallId,
+                  argsTextDelta: chunk.argsTextDelta
+                }
+              };
+            }
+            break;
+          case "finish":
+            if (textBuffer) {
+              if (isInsideThinkTag) {
+                reasoningText += textBuffer;
+                yield {
+                  type: "thinking_delta" /* THINKING_DELTA */,
+                  timestamp: Date.now(),
+                  data: { content: textBuffer }
+                };
+              } else {
+                if (!hasStartedText) {
+                  hasStartedText = true;
+                  yield {
+                    type: "text_start" /* TEXT_START */,
+                    timestamp: Date.now(),
+                    data: {}
+                  };
+                }
+                fullText += textBuffer;
+                yield {
+                  type: "text_delta" /* TEXT_DELTA */,
+                  timestamp: Date.now(),
+                  data: { content: textBuffer }
+                };
+              }
+              textBuffer = "";
+            }
+            if (isInsideThinkTag || hasStartedReasoning && !hasStartedText) {
+              yield {
+                type: "thinking_end" /* THINKING_END */,
+                timestamp: Date.now(),
+                data: {}
+              };
+              isInsideThinkTag = false;
+            }
+            if (hasStartedText) {
+              yield {
+                type: "text_end" /* TEXT_END */,
+                timestamp: Date.now(),
+                data: {}
+              };
+            }
+            break;
+          case "error":
+            yield {
+              type: "error" /* ERROR */,
+              timestamp: Date.now(),
+              data: { error: chunk.error }
+            };
+            break;
+        }
+      }
+      if (toolCalls.length === 0) {
+        yield {
+          type: "iteration_end" /* ITERATION_END */,
+          timestamp: Date.now(),
+          data: { iteration }
+        };
+        break;
+      }
+      if (fullText) {
+        yield {
+          type: "thinking_content" /* THINKING_CONTENT */,
+          timestamp: Date.now(),
+          data: { content: fullText }
+        };
+      }
+      const toolResults = [];
+      for (const toolCall of toolCalls) {
+        const toolName = toolCall.toolName;
+        const toolArgs = toolCall.args;
+        const toolCallId = toolCall.toolCallId;
+        yield {
+          type: "tool_executing" /* TOOL_EXECUTING */,
+          timestamp: Date.now(),
+          data: { toolName, toolCallId, toolArgs }
+        };
+        const toolStartTime = Date.now();
+        let result;
+        let isError = false;
+        try {
+          result = await this.mcpManager.callTool(toolName, toolArgs);
+        } catch (error) {
+          result = error instanceof Error ? error.message : String(error);
+          isError = true;
+        }
+        const duration = Date.now() - toolStartTime;
+        yield {
+          type: "tool_result" /* TOOL_RESULT */,
+          timestamp: Date.now(),
+          data: {
+            toolName,
+            toolResult: result,
+            toolCallId,
+            duration,
+            isError
+          }
+        };
+        toolResults.push({
+          toolCallId,
+          toolName,
+          result,
+          isError,
+          duration
+        });
+      }
+      messages.push({
+        role: "assistant",
+        content: [
+          ...fullText ? [{ type: "text", text: fullText }] : [],
+          ...toolCalls.map((tc) => ({
+            type: "tool-call",
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            args: tc.args
+          }))
+        ]
+      });
+      for (const tr of toolResults) {
+        messages.push({
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: tr.toolCallId,
+              toolName: tr.toolName,
+              result: tr.result
+            }
+          ]
+        });
+      }
+      yield {
+        type: "iteration_end" /* ITERATION_END */,
+        timestamp: Date.now(),
+        data: { iteration }
+      };
+    }
+    const totalDuration = Date.now() - startTime;
+    yield {
+      type: "complete" /* COMPLETE */,
+      timestamp: Date.now(),
+      data: {
+        totalIterations: iteration,
+        totalDuration
+      }
+    };
+  }
+};
+var PromptBasedAgent = class {
+  model;
+  mcpManager;
+  systemPrompt;
+  maxIterations;
+  constructor(model, mcpManager, options = {}) {
+    this.model = model;
+    this.mcpManager = mcpManager;
+    this.systemPrompt = options.systemPrompt || "";
+    this.maxIterations = options.maxIterations || 10;
+  }
+  /**
+   * 生成工具列表描述
+   */
+  generateToolsDescription(tools) {
+    if (tools.length === 0) {
+      return "\u5F53\u524D\u6CA1\u6709\u53EF\u7528\u7684\u5DE5\u5177\u3002";
+    }
+    let description = "";
+    for (const tool of tools) {
+      description += `### ${tool.name}
+`;
+      description += `\u63CF\u8FF0: ${tool.description}
+`;
+      description += `\u53C2\u6570: ${JSON.stringify(tool.inputSchema, null, 2)}
+
+`;
+    }
+    return description;
+  }
+  /**
+   * 内置系统提示词 - 强调格式约束
+   */
+  BUILT_IN_PROMPT = `
+## \u5DE5\u5177\u8C03\u7528\u683C\u5F0F\uFF08\u5FC5\u987B\u4E25\u683C\u9075\u5B88\uFF09
+
+\u5F53\u4F60\u9700\u8981\u83B7\u53D6\u6570\u636E\u6216\u6267\u884C\u64CD\u4F5C\u65F6\uFF0C**\u53EA\u80FD**\u4F7F\u7528\u4EE5\u4E0B\u683C\u5F0F\uFF1A
+
+<tool_call>
+{"name": "\u5DE5\u5177\u540D\u79F0", "arguments": {"\u53C2\u6570\u540D": "\u503C"}}
+</tool_call>
+
+### \u5DE5\u4F5C\u6D41\u7A0B
+1. \u5206\u6790\u7528\u6237\u9700\u6C42
+2. \u5982\u9700\u6570\u636E\uFF0C\u8F93\u51FA <tool_call>...</tool_call> \u540E**\u7ACB\u5373\u505C\u6B62**
+3. \u7CFB\u7EDF\u4F1A\u6267\u884C\u5DE5\u5177\u5E76\u8FD4\u56DE\u771F\u5B9E\u7ED3\u679C
+4. \u6536\u5230\u7ED3\u679C\u540E\uFF0C\u7528\u4E2D\u6587\u6574\u7406\u56DE\u590D\u7528\u6237
+
+### \u4E25\u683C\u7981\u6B62
+- \u274C \u81EA\u5DF1\u7F16\u5199\u5DE5\u5177\u8FD4\u56DE\u7ED3\u679C\uFF08\u5982 \`\u7ED3\u679C:{...}\` \u6216 \`{"code":200...}\`\uFF09
+- \u274C \u6A21\u62DF\u5DE5\u5177\u8C03\u7528\uFF08\u5982 \`RPCCall:\`\u3001\`FunctionCall:\`\uFF09
+- \u274C \u5728\u6CA1\u6709\u771F\u5B9E\u5DE5\u5177\u7ED3\u679C\u7684\u60C5\u51B5\u4E0B\u7F16\u9020\u6570\u636E
+- \u274C \u4E00\u6B21\u8F93\u51FA\u4E2D\u540C\u65F6\u5305\u542B\u5DE5\u5177\u8C03\u7528\u548C\u6700\u7EC8\u56DE\u590D
+
+### \u6B63\u786E\u793A\u4F8B
+\u7528\u6237: "\u67E5\u8BE2\u6211\u7684\u8BA2\u5355"
+\u4F60\u7684\u8F93\u51FA:
+<tool_call>
+{"name": "get_orders", "arguments": {"token": "xxx"}}
+</tool_call>
+
+\uFF08\u7136\u540E\u505C\u6B62\uFF0C\u7B49\u5F85\u7CFB\u7EDF\u8FD4\u56DE\u771F\u5B9E\u7ED3\u679C\uFF09
+
+### \u56DE\u590D\u683C\u5F0F
+- \u4F7F\u7528\u4E2D\u6587
+- \u4F7F\u7528 Markdown \u683C\u5F0F\u7F8E\u5316\u8F93\u51FA
+- \u5217\u8868\u6570\u636E\u6BCF\u9879\u72EC\u5360\u4E00\u884C
+`;
+  /**
+   * 构建完整的系统提示词
+   */
+  buildSystemPrompt(tools) {
+    const toolsDescription = this.generateToolsDescription(tools);
+    const userPrompt = this.systemPrompt || "\u4F60\u662F\u4E00\u4E2A\u667A\u80FD\u52A9\u624B\u3002";
+    return `${userPrompt}
+
+## \u53EF\u7528\u5DE5\u5177
+${toolsDescription}
+${this.BUILT_IN_PROMPT}`;
+  }
+  /**
+   * 解析工具调用
+   */
+  parseToolCall(text) {
+    const tagMatch = text.match(/<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/i);
+    if (tagMatch) {
+      try {
+        const json = JSON.parse(tagMatch[1].trim());
+        if (json.name) return { name: json.name, arguments: json.arguments || {} };
+      } catch {
+      }
+    }
+    const codeMatch = text.match(/```(?:json)?\s*\n?\s*(\{[\s\S]*?"name"[\s\S]*?\})\s*\n?\s*```/i);
+    if (codeMatch) {
+      try {
+        const json = JSON.parse(codeMatch[1].trim());
+        if (json.name) return { name: json.name, arguments: json.arguments || {} };
+      } catch {
+      }
+    }
+    const jsonMatch = text.match(/\{\s*"name"\s*:\s*"([^"]+)"[\s\S]*?"arguments"\s*:\s*(\{[\s\S]*?\})\s*\}/i);
+    if (jsonMatch) {
+      try {
+        const fullMatch = jsonMatch[0];
+        const json = JSON.parse(fullMatch);
+        if (json.name) return { name: json.name, arguments: json.arguments || {} };
+      } catch {
+      }
+    }
+    return null;
+  }
+  /**
+   * 智能压缩历史消息
+   * - 用户消息完整保留
+   * - AI 回复保留关键信息（ID、名称、数量、价格等）
+   * - 去除冗长的 JSON 原始数据
+   */
+  compressHistory(history) {
+    const MAX_USER_MESSAGE_LENGTH = 500;
+    const MAX_ASSISTANT_MESSAGE_LENGTH = 1500;
+    const recentHistory = history.slice(-20);
+    return recentHistory.map((msg) => {
+      if (msg.role === "user") {
+        if (msg.content.length <= MAX_USER_MESSAGE_LENGTH) {
+          return msg;
+        }
+        return {
+          role: msg.role,
+          content: msg.content.slice(0, MAX_USER_MESSAGE_LENGTH) + "..."
+        };
+      }
+      let content = msg.content;
+      content = content.replace(/```json\n[\s\S]*?\n```/g, "[\u5DE5\u5177\u8FD4\u56DE\u6570\u636E]");
+      content = content.replace(/## .*?\(原始JSON\)[\s\S]*?(?=##|$)/g, "");
+      if (content.length > MAX_ASSISTANT_MESSAGE_LENGTH) {
+        const tableMatch = content.match(/\|[\s\S]*?\|/g);
+        if (tableMatch) {
+          const tables = tableMatch.join("\n");
+          if (tables.length < MAX_ASSISTANT_MESSAGE_LENGTH) {
+            content = content.slice(0, MAX_ASSISTANT_MESSAGE_LENGTH - tables.length) + "\n" + tables;
+          }
+        }
+        content = content.slice(0, MAX_ASSISTANT_MESSAGE_LENGTH) + "...";
+      }
+      return { role: msg.role, content: content.trim() || msg.content.slice(0, 500) };
+    });
+  }
+  /**
+   * 流式对话
+   */
+  async *chatStream(userMessage, options) {
+    const startTime = Date.now();
+    let mcpTools = this.mcpManager.getAllTools();
+    if (options?.allowedTools?.length) {
+      mcpTools = mcpTools.filter((t) => options.allowedTools.includes(t.name));
+    }
+    const messages = [
+      { role: "system", content: this.buildSystemPrompt(mcpTools) }
+    ];
+    if (options?.history?.length) {
+      const compressedHistory = this.compressHistory(options.history);
+      console.log(`[PromptBasedAgent] \u{1F4DA} \u5386\u53F2\u6D88\u606F: ${options.history.length} \u6761 -> \u538B\u7F29\u540E: ${compressedHistory.length} \u6761`);
+      for (const msg of compressedHistory) {
+        messages.push({ role: msg.role, content: msg.content });
+      }
+    }
+    messages.push({ role: "user", content: userMessage });
+    console.log(`[PromptBasedAgent] \u{1F4DD} \u7528\u6237\u6D88\u606F: "${userMessage.slice(0, 50)}${userMessage.length > 50 ? "..." : ""}"`);
+    console.log(`[PromptBasedAgent] \u{1F4CA} \u603B\u6D88\u606F\u6570: ${messages.length}`);
+    let iteration = 0;
+    while (iteration < this.maxIterations) {
+      iteration++;
+      yield {
+        type: "iteration_start" /* ITERATION_START */,
+        timestamp: Date.now(),
+        data: { iteration, maxIterations: this.maxIterations }
+      };
+      console.log(`[PromptBasedAgent] \u{1F916} \u8C03\u7528\u6A21\u578B\uFF0C\u8FED\u4EE3 ${iteration}/${this.maxIterations}...`);
+      const modelStartTime = Date.now();
+      const stream = streamText({
+        model: this.model,
+        messages,
+        // 设置请求超时
+        experimental_telemetry: {
+          isEnabled: false
+          // 禁用遥测以减少开销
+        }
+      });
+      let fullResponse = "";
+      let buffer = "";
+      let inThinking = false;
+      let inToolCall = false;
+      let thinkingStarted = false;
+      let thinkingEnded = false;
+      let textStarted = false;
+      let firstChunkReceived = false;
+      const FIRST_CHUNK_TIMEOUT = 12e4;
+      let timeoutId = null;
+      new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(new Error(`\u6A21\u578B\u54CD\u5E94\u8D85\u65F6 (${FIRST_CHUNK_TIMEOUT / 1e3}\u79D2\u65E0\u54CD\u5E94)`));
+        }, FIRST_CHUNK_TIMEOUT);
+      });
+      try {
+        for await (const chunk of stream.fullStream) {
+          if (!firstChunkReceived) {
+            firstChunkReceived = true;
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+              timeoutId = null;
+            }
+            console.log(`[PromptBasedAgent] \u26A1 \u9996\u4E2A chunk \u5230\u8FBE\uFF0C\u8017\u65F6: ${Date.now() - modelStartTime}ms`);
+          }
+          if (chunk.type === "reasoning") {
+            if (!thinkingStarted) {
+              thinkingStarted = true;
+              yield { type: "thinking_start" /* THINKING_START */, timestamp: Date.now(), data: {} };
+            }
+            if (chunk.textDelta) {
+              yield { type: "thinking_delta" /* THINKING_DELTA */, timestamp: Date.now(), data: { content: chunk.textDelta } };
+            }
+            continue;
+          }
+          if (chunk.type === "text-delta") {
+            const delta = chunk.textDelta;
+            buffer += delta;
+            fullResponse += delta;
+            while (buffer.length > 0) {
+              if (!inThinking && !inToolCall) {
+                const thinkStart = buffer.indexOf("<think>");
+                if (thinkStart !== -1) {
+                  if (thinkStart > 0) {
+                    const before = buffer.substring(0, thinkStart);
+                    if (before.trim() && thinkingEnded) {
+                      if (!textStarted) {
+                        textStarted = true;
+                        yield { type: "text_start" /* TEXT_START */, timestamp: Date.now(), data: {} };
+                      }
+                      yield { type: "text_delta" /* TEXT_DELTA */, timestamp: Date.now(), data: { content: before } };
+                    }
+                  }
+                  inThinking = true;
+                  if (!thinkingStarted) {
+                    thinkingStarted = true;
+                    yield { type: "thinking_start" /* THINKING_START */, timestamp: Date.now(), data: {} };
+                  }
+                  buffer = buffer.substring(thinkStart + 7);
+                  continue;
+                }
+                const toolStart = buffer.indexOf("<tool_call>");
+                if (toolStart !== -1) {
+                  if (toolStart > 0) {
+                    const before = buffer.substring(0, toolStart);
+                    if (before.trim() && thinkingEnded) {
+                      if (!textStarted) {
+                        textStarted = true;
+                        yield { type: "text_start" /* TEXT_START */, timestamp: Date.now(), data: {} };
+                      }
+                      yield { type: "text_delta" /* TEXT_DELTA */, timestamp: Date.now(), data: { content: before } };
+                    }
+                  }
+                  inToolCall = true;
+                  buffer = buffer.substring(toolStart + 11);
+                  continue;
+                }
+                if (!buffer.includes("<")) {
+                  if (buffer.trim() && (thinkingEnded || !thinkingStarted)) {
+                    if (!thinkingStarted && !thinkingEnded) {
+                      thinkingStarted = true;
+                      thinkingEnded = true;
+                      yield { type: "thinking_start" /* THINKING_START */, timestamp: Date.now(), data: {} };
+                      yield { type: "thinking_delta" /* THINKING_DELTA */, timestamp: Date.now(), data: { content: "\u5206\u6790\u7528\u6237\u8BF7\u6C42..." } };
+                      yield { type: "thinking_end" /* THINKING_END */, timestamp: Date.now(), data: {} };
+                    }
+                    if (!textStarted) {
+                      textStarted = true;
+                      yield { type: "text_start" /* TEXT_START */, timestamp: Date.now(), data: {} };
+                    }
+                    yield { type: "text_delta" /* TEXT_DELTA */, timestamp: Date.now(), data: { content: buffer } };
+                  }
+                  buffer = "";
+                }
+                break;
+              }
+              if (inThinking) {
+                const thinkEnd = buffer.indexOf("</think>");
+                if (thinkEnd !== -1) {
+                  const content = buffer.substring(0, thinkEnd);
+                  if (content) {
+                    yield { type: "thinking_delta" /* THINKING_DELTA */, timestamp: Date.now(), data: { content } };
+                  }
+                  yield { type: "thinking_end" /* THINKING_END */, timestamp: Date.now(), data: {} };
+                  thinkingEnded = true;
+                  inThinking = false;
+                  buffer = buffer.substring(thinkEnd + 8);
+                  continue;
+                }
+                if (buffer.length > 10 && !buffer.includes("<")) {
+                  const safe = buffer.substring(0, buffer.length - 10);
+                  yield { type: "thinking_delta" /* THINKING_DELTA */, timestamp: Date.now(), data: { content: safe } };
+                  buffer = buffer.substring(safe.length);
+                }
+                break;
+              }
+              if (inToolCall) {
+                const toolEnd = buffer.indexOf("</tool_call>");
+                if (toolEnd !== -1) {
+                  inToolCall = false;
+                  buffer = buffer.substring(toolEnd + 12);
+                  continue;
+                }
+                break;
+              }
+              break;
+            }
+          }
+          if (chunk.type === "finish") {
+            if (buffer.trim()) {
+              if (inThinking) {
+                yield { type: "thinking_delta" /* THINKING_DELTA */, timestamp: Date.now(), data: { content: buffer } };
+                yield { type: "thinking_end" /* THINKING_END */, timestamp: Date.now(), data: {} };
+                thinkingEnded = true;
+              } else if (!inToolCall) {
+                if (!textStarted) {
+                  textStarted = true;
+                  yield { type: "text_start" /* TEXT_START */, timestamp: Date.now(), data: {} };
+                }
+                yield { type: "text_delta" /* TEXT_DELTA */, timestamp: Date.now(), data: { content: buffer } };
+              }
+            }
+            if (textStarted) {
+              yield { type: "text_end" /* TEXT_END */, timestamp: Date.now(), data: {} };
+            }
+          }
+        }
+      } finally {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+      }
+      const toolCall = this.parseToolCall(fullResponse);
+      if (toolCall) {
+        const toolCallId = `tool-${Date.now()}`;
+        yield {
+          type: "tool_call_start" /* TOOL_CALL_START */,
+          timestamp: Date.now(),
+          data: { toolName: toolCall.name, toolCallId, toolArgs: toolCall.arguments }
+        };
+        yield {
+          type: "tool_executing" /* TOOL_EXECUTING */,
+          timestamp: Date.now(),
+          data: { toolName: toolCall.name, toolCallId, toolArgs: toolCall.arguments }
+        };
+        const toolStartTime = Date.now();
+        let result;
+        let isError = false;
+        try {
+          result = await this.mcpManager.callTool(toolCall.name, toolCall.arguments);
+        } catch (error) {
+          result = error instanceof Error ? error.message : String(error);
+          isError = true;
+        }
+        const duration = Date.now() - toolStartTime;
+        yield {
+          type: "tool_result" /* TOOL_RESULT */,
+          timestamp: Date.now(),
+          data: { toolName: toolCall.name, toolResult: result, toolCallId, duration, isError }
+        };
+        messages.push({ role: "assistant", content: fullResponse });
+        const resultStr = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+        messages.push({
+          role: "user",
+          content: `\u5DE5\u5177 ${toolCall.name} \u8FD4\u56DE\u7ED3\u679C\uFF1A
+${resultStr}
+
+\u8BF7\u6839\u636E\u7ED3\u679C\u7528\u4E2D\u6587\u56DE\u590D\u7528\u6237\u3002`
+        });
+        yield { type: "iteration_end" /* ITERATION_END */, timestamp: Date.now(), data: { iteration } };
+        continue;
+      }
+      console.log(`[PromptBasedAgent] \u2705 \u6A21\u578B\u54CD\u5E94\u5B8C\u6210\uFF0C\u8017\u65F6: ${Date.now() - modelStartTime}ms\uFF0C\u54CD\u5E94\u957F\u5EA6: ${fullResponse.length}`);
+      if (!textStarted && fullResponse.trim()) {
+        let cleanText = fullResponse.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, "").trim();
+        if (cleanText) {
+          yield { type: "text_start" /* TEXT_START */, timestamp: Date.now(), data: {} };
+          yield { type: "text_delta" /* TEXT_DELTA */, timestamp: Date.now(), data: { content: cleanText } };
+          yield { type: "text_end" /* TEXT_END */, timestamp: Date.now(), data: {} };
+        }
+      }
+      yield { type: "iteration_end" /* ITERATION_END */, timestamp: Date.now(), data: { iteration } };
+      break;
+    }
+    yield {
+      type: "complete" /* COMPLETE */,
+      timestamp: Date.now(),
+      data: { totalDuration: Date.now() - startTime, totalIterations: iteration }
+    };
+  }
+};
+
+// src/MCPLink.ts
+var NATIVE_FUNCTION_CALLING_PATTERNS = [
+  // OpenAI GPT 系列 - 支持原生 function calling
+  /^gpt/i,
+  // OpenAI o1/o3 需要特殊处理，暂用 PromptBased
+  // /^o1/i,
+  // /^o3/i,
+  // Anthropic Claude - 支持原生 function calling
+  /^claude/i,
+  // Google Gemini 稳定版 - 支持原生 function calling
+  // 注意：gemini-*-preview/thinking 版本需要特殊处理，不在此列表
+  /^gemini-[\d.]+-flash$/i,
+  /^gemini-[\d.]+-pro$/i,
+  /^gemini-pro$/i,
+  /^gemini-flash$/i,
+  // Mistral - 支持原生 function calling
+  /^mistral/i,
+  /^mixtral/i,
+  // Cohere Command-R - 支持原生 function calling
+  /^command-r/i
+];
+var PROMPT_BASED_PATTERNS = [
+  // DeepSeek（不支持原生 function calling）
+  /deepseek/i,
+  // OpenAI o1/o3 思考模型
+  /^o1/i,
+  /^o3/i,
+  // Gemini 思考/预览版本 - 需要 thought_signature，暂用 PromptBased
+  /gemini.*preview/i,
+  /gemini.*thinking/i,
+  /gemini.*exp/i,
+  // 开源模型（大多数不支持原生 function calling）
+  /^llama/i,
+  /^phi-/i,
+  /^qwen/i,
+  /^yi-/i,
+  /^glm/i,
+  /^baichuan/i
+];
+function detectNativeToolSupport(modelId) {
+  console.log(`[MCPLink] \u{1F50D} \u68C0\u6D4B\u6A21\u578B: "${modelId}"`);
+  for (const pattern of PROMPT_BASED_PATTERNS) {
+    if (pattern.test(modelId)) {
+      console.log(`[MCPLink] \u2705 Model "${modelId}" -> PromptBasedAgent (matched: ${pattern})`);
+      return false;
+    }
+  }
+  for (const pattern of NATIVE_FUNCTION_CALLING_PATTERNS) {
+    if (pattern.test(modelId)) {
+      console.log(`[MCPLink] \u2705 Model "${modelId}" -> Agent (\u539F\u751F\u6A21\u5F0F, matched: ${pattern})`);
+      return true;
+    }
+  }
+  console.log(`[MCPLink] \u26A0\uFE0F Model "${modelId}" -> PromptBasedAgent (\u672A\u77E5\u6A21\u578B\uFF0C\u9ED8\u8BA4)`);
+  return false;
+}
+var MCPLink = class {
+  model;
+  mcpManager;
+  agent;
+  promptBasedAgent;
+  config;
+  initialized = false;
+  detectedNativeSupport;
+  constructor(config) {
+    this.config = config;
+    this.model = config.model;
+    this.mcpManager = new MCPManager();
+    if (config.mcpServers) {
+      for (const [id, serverConfig] of Object.entries(config.mcpServers)) {
+        this.mcpManager.addServer(id, serverConfig);
+      }
+    }
+    this.agent = new Agent(this.model, this.mcpManager, {
+      systemPrompt: config.systemPrompt,
+      maxIterations: config.maxIterations
+    });
+    this.promptBasedAgent = new PromptBasedAgent(this.model, this.mcpManager, {
+      systemPrompt: config.systemPrompt,
+      maxIterations: config.maxIterations
+    });
+    if (config.usePromptBasedTools === true) {
+      this.detectedNativeSupport = false;
+    } else if (config.usePromptBasedTools === false) {
+      this.detectedNativeSupport = true;
+    } else {
+      const modelNameToCheck = config.modelName || config.model.modelId;
+      this.detectedNativeSupport = detectNativeToolSupport(modelNameToCheck);
+    }
+  }
+  /**
+   * 初始化 - 连接所有 MCP 服务器
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    await this.mcpManager.startAll();
+    this.initialized = true;
+  }
+  /**
+   * 关闭 - 断开所有 MCP 服务器连接
+   */
+  async close() {
+    await this.mcpManager.stopAll();
+    this.initialized = false;
+  }
+  /**
+   * 发起对话
+   */
+  async chat(message, callbacks) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return this.agent.chat(message, callbacks);
+  }
+  /**
+   * 流式对话
+   * @param message 用户消息
+   * @param options 可选参数
+   * @param options.allowedTools 允许使用的工具名称列表
+   * @param options.history 历史消息列表
+   */
+  async *chatStream(message, options) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (this.detectedNativeSupport) {
+      yield* this.agent.chatStream(message, options);
+    } else {
+      yield* this.promptBasedAgent.chatStream(message, options);
+    }
+  }
+  /**
+   * 获取当前使用的模式
+   */
+  getToolCallingMode() {
+    return this.detectedNativeSupport ? "native" : "prompt-based";
+  }
+  // ============ MCP 服务器管理 ============
+  /**
+   * 添加 MCP 服务器
+   */
+  addMCPServer(id, config) {
+    this.mcpManager.addServer(id, config);
+  }
+  /**
+   * 移除 MCP 服务器
+   */
+  async removeMCPServer(id) {
+    await this.mcpManager.removeServer(id);
+  }
+  /**
+   * 启动指定 MCP 服务器
+   */
+  async startMCPServer(id) {
+    await this.mcpManager.startServer(id);
+  }
+  /**
+   * 停止指定 MCP 服务器
+   */
+  async stopMCPServer(id) {
+    await this.mcpManager.stopServer(id);
+  }
+  /**
+   * 获取所有 MCP 服务器状态
+   */
+  getMCPServerStatuses() {
+    return this.mcpManager.getServerStatuses();
+  }
+  /**
+   * 获取所有可用工具
+   */
+  getTools() {
+    return this.mcpManager.getAllTools();
+  }
+  /**
+   * 手动调用工具
+   */
+  async callTool(toolName, args) {
+    return this.mcpManager.callTool(toolName, args);
+  }
+  // ============ 配置管理 ============
+  /**
+   * 更新系统提示词
+   */
+  setSystemPrompt(prompt) {
+    this.config.systemPrompt = prompt;
+    this.agent = new Agent(this.model, this.mcpManager, {
+      systemPrompt: prompt,
+      maxIterations: this.config.maxIterations
+    });
+  }
+  /**
+   * 更新 AI 模型
+   */
+  setModel(model) {
+    this.model = model;
+    this.config.model = model;
+    this.agent = new Agent(this.model, this.mcpManager, {
+      systemPrompt: this.config.systemPrompt,
+      maxIterations: this.config.maxIterations
+    });
+  }
+};
+
+export { Agent, DEFAULT_SYSTEM_PROMPT, MCPLink, MCPLinkEventType, MCPManager, PromptBasedAgent };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map