@n0ts123/mcplink-core 0.0.12 → 0.0.14

package/dist/index.js

@@ -1,10 +1,7 @@
 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 { generateText, streamText } from 'ai';
-import { z } from 'zod';
-export { createOpenAI } from '@ai-sdk/openai';
-export { createAnthropic } from '@ai-sdk/anthropic';
+import axios from 'axios';
 
 // src/MCPManager.ts
 var RECONNECT_ERROR_KEYWORDS = [
@@ -325,1542 +322,285 @@ var MCPManager = class {
     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["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_EXECUTING"] = "tool_executing";
-  MCPLinkEventType2["TOOL_RESULT"] = "tool_result";
-  MCPLinkEventType2["IMMEDIATE_RESULT"] = "immediate_result";
-  MCPLinkEventType2["ITERATION_START"] = "iteration_start";
-  MCPLinkEventType2["ITERATION_END"] = "iteration_end";
-  MCPLinkEventType2["COMPLETE"] = "complete";
-  MCPLinkEventType2["ERROR"] = "error";
-  return MCPLinkEventType2;
-})(MCPLinkEventType || {});
-
-// src/Agent.ts
-var DEFAULT_SYSTEM_PROMPT = `\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u3001\u53CB\u597D\u7684\u667A\u80FD\u52A9\u624B\u3002
-
-## \u56DE\u590D\u8981\u6C42
-- \u7B80\u6D01\u6E05\u6670\uFF0C\u91CD\u70B9\u7A81\u51FA
-- \u7528\u5217\u8868\u5448\u73B0\u5173\u952E\u4FE1\u606F
-- \u8BED\u6C14\u793C\u8C8C\u81EA\u7136\uFF0C\u50CF\u4E13\u4E1A\u52A9\u624B
-- \u6709\u7ED3\u8BBA\u65F6\u76F4\u63A5\u7ED9\u51FA\uFF0C\u9700\u8981\u8865\u5145\u4FE1\u606F\u65F6\u7B80\u5355\u8BE2\u95EE`;
-var DEFAULT_THINKING_PHASE_PROMPT = `
----
-\u8FD9\u662F\u4F60\u7684\u5185\u5FC3\u72EC\u767D\uFF0C\u7528\u6237\u770B\u4E0D\u5230\u3002
-
-\u5224\u65AD\u5F53\u524D\u72B6\u6001\uFF1A\u6211\u62FF\u5230\u4E86\u4EC0\u4E48\uFF1F\u4EFB\u52A1\u5B8C\u6210\u4E86\u5417\uFF1F\u8FD8\u9700\u8981\u67E5\u4EC0\u4E48\uFF1F
-
-\u91CD\u8981\uFF1A\u8FD9\u91CC\u53EA\u662F\u601D\u8003\u5224\u65AD\uFF0C\u4E0D\u8981\u5728\u8FD9\u91CC\u5199\u56DE\u590D\u5185\u5BB9\uFF08\u56DE\u590D\u662F\u4E0B\u4E00\u6B65\u7684\u4E8B\uFF09\u3002
----`;
-var Agent = class {
-  model;
-  mcpManager;
-  systemPrompt;
-  maxIterations;
-  immediateResultMatchers;
-  parallelToolCalls;
-  enableThinkingPhase;
-  thinkingPhasePrompt;
-  thinkingMaxTokens;
-  constructor(model, mcpManager, options = {}) {
-    this.model = model;
-    this.mcpManager = mcpManager;
-    this.systemPrompt = options.systemPrompt || DEFAULT_SYSTEM_PROMPT;
-    this.maxIterations = options.maxIterations || 10;
-    this.immediateResultMatchers = options.immediateResultMatchers || [];
-    this.parallelToolCalls = options.parallelToolCalls ?? true;
-    this.enableThinkingPhase = options.enableThinkingPhase ?? false;
-    this.thinkingPhasePrompt = options.thinkingPhasePrompt || DEFAULT_THINKING_PHASE_PROMPT;
-    this.thinkingMaxTokens = options.thinkingMaxTokens ?? 1e3;
+var HttpClient = class {
+  client;
+  constructor() {
+    this.client = axios.create({
+      timeout: 12e4
+    });
   }
   /**
-   * 生成工具描述文本（用于思考阶段）
+   * 非流式请求
    */
-  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}
-`;
-      if (tool.inputSchema.properties) {
-        description += `\u53C2\u6570:
-`;
-        for (const [key, prop] of Object.entries(tool.inputSchema.properties)) {
-          const propInfo = prop;
-          const required = tool.inputSchema.required?.includes(key) ? "\u5FC5\u586B" : "\u53EF\u9009";
-          description += `  - ${key} (${propInfo.type || "any"}, ${required}): ${propInfo.description || ""}
-`;
-        }
+  async chat(aiConfig, adapter, messages, tools) {
+    const body = adapter.buildRequestBody(aiConfig, messages, tools);
+    const headers = { ...adapter.getHeaders(aiConfig), ...aiConfig.headers };
+    const response = await this.client.post(
+      adapter.getEndpoint(aiConfig.baseURL),
+      body,
+      {
+        headers,
+        timeout: aiConfig.timeout || 12e4
       }
-      description += "\n";
-    }
-    return description;
+    );
+    return adapter.parseResponse(response.data);
   }
   /**
-   * 摘要化工具返回结果（用于思考阶段，避免 AI 直接格式化输出数据）
-   * @param toolName 工具名称
-   * @param result 工具返回的结果
-   * @returns 摘要字符串
+   * 流式请求 - SSE
    */
-  summarizeToolResult(toolName, result) {
-    let count = 0;
-    let resultObj = result;
-    if (typeof result === "string") {
-      try {
-        resultObj = JSON.parse(result);
-      } catch {
-        return `[\u5DE5\u5177 ${toolName} \u8FD4\u56DE\u4E86\u6570\u636E]`;
+  async *streamChat(aiConfig, adapter, messages, tools) {
+    const body = adapter.buildRequestBody(aiConfig, messages, tools);
+    const streamBody = { ...body, stream: true };
+    const headers = { ...adapter.getHeaders(aiConfig), ...aiConfig.headers };
+    const response = await this.client.post(
+      adapter.getEndpoint(aiConfig.baseURL),
+      streamBody,
+      {
+        headers,
+        timeout: aiConfig.timeout || 12e4,
+        responseType: "stream"
       }
-    }
-    if (Array.isArray(resultObj)) {
-      count = resultObj.length;
-    } else if (typeof resultObj === "object" && resultObj !== null) {
-      const obj = resultObj;
-      for (const key of ["data", "list", "items", "records", "results"]) {
-        if (Array.isArray(obj[key])) {
-          count = obj[key].length;
-          break;
-        }
+    );
+    const stream = response.data;
+    for await (const event of this.parseSSE(stream)) {
+      const parsed = adapter.parseStreamChunk(event);
+      if (parsed) {
+        yield parsed;
       }
     }
-    if (count > 0) {
-      return `[\u5DE5\u5177 ${toolName} \u8FD4\u56DE\u4E86\u6570\u636E\uFF0C\u5305\u542B ${count} \u6761\u8BB0\u5F55]`;
-    }
-    return `[\u5DE5\u5177 ${toolName} \u8FD4\u56DE\u4E86\u6570\u636E]`;
   }
   /**
-   * 检查工具返回结果是否匹配即时结果匹配器
-   * @param result 工具返回的结果
-   * @returns 如果匹配返回 true，否则返回 false
+   * 解析 SSE 流
    */
-  matchImmediateResult(result) {
-    const debug = process.env.DEBUG_MCPLINK === "true";
-    if (!this.immediateResultMatchers.length) {
-      if (debug) console.log("[MCPLink] \u26A0\uFE0F \u672A\u914D\u7F6E\u5373\u65F6\u7ED3\u679C\u5339\u914D\u5668");
-      return false;
-    }
-    let resultObj = null;
-    if (typeof result === "string") {
-      try {
-        const parsed = JSON.parse(result);
-        if (typeof parsed === "object" && parsed !== null) {
-          resultObj = parsed;
-          if (debug) console.log("[MCPLink] \u{1F50D} \u89E3\u6790\u5DE5\u5177\u7ED3\u679C\u4E3A\u5BF9\u8C61:", Object.keys(parsed));
+  async *parseSSE(stream) {
+    let buffer = "";
+    for await (const chunk of stream) {
+      buffer += chunk.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("data: ")) {
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") {
+            return;
+          }
+          if (data) {
+            yield data;
+          }
         }
-      } catch {
-        if (debug) console.log("[MCPLink] \u26A0\uFE0F \u5DE5\u5177\u7ED3\u679C\u4E0D\u662F\u6709\u6548 JSON");
       }
-    } else if (typeof result === "object" && result !== null) {
-      resultObj = result;
-      if (debug) console.log("[MCPLink] \u{1F50D} \u5DE5\u5177\u7ED3\u679C\u662F\u5BF9\u8C61:", Object.keys(result));
-    }
-    if (!resultObj) {
-      if (debug) console.log("[MCPLink] \u26A0\uFE0F \u65E0\u6CD5\u89E3\u6790\u5DE5\u5177\u7ED3\u679C\u4E3A\u5BF9\u8C61");
-      return false;
     }
-    for (const matcher of this.immediateResultMatchers) {
-      let matched = true;
-      for (const [key, value] of Object.entries(matcher)) {
-        if (resultObj[key] !== value) {
-          matched = false;
-          break;
-        }
-      }
-      if (matched) {
-        if (debug) console.log("[MCPLink] \u2705 \u5373\u65F6\u7ED3\u679C\u5339\u914D\u6210\u529F:", JSON.stringify(matcher));
-        return true;
+    if (buffer.trim().startsWith("data: ")) {
+      const data = buffer.trim().slice(6);
+      if (data && data !== "[DONE]") {
+        yield data;
       }
     }
-    if (debug) console.log("[MCPLink] \u274C \u5373\u65F6\u7ED3\u679C\u672A\u5339\u914D\uFF0C\u671F\u671B:", JSON.stringify(this.immediateResultMatchers), "\u5B9E\u9645:", JSON.stringify(resultObj));
-    return false;
   }
+};
+
+// src/adapters/openai.ts
+var OpenAIAdapter = class {
+  name = "openai";
+  // 用于累积 tool_call 参数的状态
+  pendingToolCall = null;
   /**
-   * 将 MCP 工具转换为 Vercel AI SDK 格式
+   * 检查 tool_call 参数是否完整（可以解析为 JSON）
    */
-  convertMCPToolsToAITools(mcpTools) {
-    const tools = {};
-    for (const mcpTool of mcpTools) {
-      const zodSchema = this.jsonSchemaToZod(mcpTool.inputSchema);
-      tools[mcpTool.name] = {
-        description: mcpTool.description,
-        parameters: zodSchema
-      };
+  isToolCallComplete(tc) {
+    if (!tc.arguments) return false;
+    try {
+      JSON.parse(tc.arguments);
+      return true;
+    } catch {
+      return false;
     }
-    return tools;
   }
   /**
-   * JSON Schema 到 Zod 的完整递归转换
-   * 支持嵌套对象、对象数组、枚举等所有常见类型
+   * 返回并清空 pending tool_call
    */
-  jsonSchemaToZod(schema) {
-    return this.convertSchemaToZod(schema, schema.required || []);
+  flushPendingToolCall() {
+    if (!this.pendingToolCall) return null;
+    const tc = this.pendingToolCall;
+    this.pendingToolCall = null;
+    return {
+      type: "tool_call",
+      toolCall: {
+        id: tc.id,
+        name: tc.name,
+        arguments: tc.arguments ? JSON.parse(tc.arguments) : {}
+      }
+    };
   }
   /**
-   * 递归转换 JSON Schema 节点为 Zod 类型
+   * 构建请求体
+   * 完全开放：除必要字段外，其他参数原封不动传递
    */
-  convertSchemaToZod(schema, parentRequired = [], key) {
-    const type = schema.type;
-    const description = schema.description;
-    const enumValues = schema.enum;
-    let zodType;
-    if (enumValues && enumValues.length > 0) {
-      if (enumValues.every((v) => typeof v === "string")) {
-        zodType = z.enum(enumValues);
-      } else if (enumValues.every((v) => typeof v === "number")) {
-        const literals = enumValues.map((v) => z.literal(v));
-        zodType = literals.length === 1 ? literals[0] : z.union([literals[0], literals[1], ...literals.slice(2)]);
-      } else {
-        zodType = z.unknown();
-      }
-    } else {
-      switch (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 "null":
-          zodType = z.null();
-          break;
-        case "object": {
-          const properties = schema.properties;
-          const required = schema.required || [];
-          if (properties) {
-            const shape = {};
-            for (const [propKey, propSchema] of Object.entries(properties)) {
-              let propZod = this.convertSchemaToZod(propSchema, required, propKey);
-              if (!required.includes(propKey)) {
-                propZod = propZod.optional();
-              }
-              shape[propKey] = propZod;
-            }
-            zodType = z.object(shape);
-          } else {
-            zodType = z.record(z.unknown());
-          }
-          break;
-        }
-        case "array": {
-          const items = schema.items;
-          if (items) {
-            const itemsRequired = items.required || [];
-            zodType = z.array(this.convertSchemaToZod(items, itemsRequired));
-          } else {
-            zodType = z.array(z.unknown());
-          }
-          break;
-        }
-        default:
-          zodType = z.unknown();
+  buildRequestBody(config, messages, tools) {
+    const { baseURL, apiKey, model, headers, timeout, ...customParams } = config;
+    const openaiMessages = messages.map((msg) => this.convertMessage(msg));
+    const openaiTools = tools?.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
       }
+    }));
+    const body = {
+      model,
+      messages: openaiMessages,
+      // 用户自定义参数（包括 enable_thinking 等）
+      ...customParams
+    };
+    if (openaiTools && openaiTools.length > 0) {
+      body.tools = openaiTools;
     }
-    if (description) {
-      zodType = zodType.describe(description);
-    }
-    return zodType;
+    return body;
   }
   /**
-   * 执行对话
+   * 获取请求头
    */
-  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 generateOptions = {
-        model: this.model,
-        messages,
-        tools: Object.keys(tools).length > 0 ? tools : void 0,
-        maxSteps: 1
-        // 每次只执行一步，方便我们控制流程
-      };
-      if (this.enableThinkingPhase) {
-        generateOptions.providerOptions = {
-          openai: {
-            enable_thinking: false
-          }
-        };
-      }
-      const response = await generateText(generateOptions);
-      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;
+  getHeaders(config) {
     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
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${config.apiKey}`
     };
   }
   /**
-   * 将 UserMessage 转换为 Vercel AI SDK 的消息内容格式
+   * 获取请求端点
    */
-  convertUserMessageToContent(message) {
-    if (typeof message === "string") {
-      return message;
-    }
-    return message.map((part) => {
-      switch (part.type) {
-        case "text":
-          return { type: "text", text: part.text };
-        case "image":
-          return { type: "image", image: part.image, mimeType: part.mimeType };
-        case "file":
-          return { type: "file", data: part.data, mimeType: part.mimeType };
-        default:
-          return { type: "text", text: "" };
-      }
-    });
+  getEndpoint(baseURL) {
+    const normalized = baseURL.replace(/\/$/, "");
+    return `${normalized}/chat/completions`;
   }
   /**
-   * 从 UserMessage 提取纯文本内容（用于日志等）
+   * 解析非流式响应
    */
-  extractTextFromMessage(message) {
-    if (typeof message === "string") {
-      return message;
-    }
-    return message.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+  parseResponse(data) {
+    const response = data;
+    const choice = response.choices[0];
+    const message = choice?.message;
+    const toolCalls = message?.tool_calls?.map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      arguments: JSON.parse(tc.function.arguments)
+    }));
+    return {
+      content: message?.content || "",
+      toolCalls: toolCalls?.length ? toolCalls : void 0
+    };
   }
   /**
-   * 流式对话 - 返回事件生成器
-   * @param userMessage 用户消息（支持字符串或多模态数组）
-   * @param options 可选参数
-   * @param options.allowedTools 允许使用的工具名称列表，为空或不传则使用所有工具
-   * @param options.history 历史消息列表
+   * 解析流式数据块
    */
-  async *chatStream(userMessage, options) {
-    const startTime = Date.now();
-    const toolCallRecords = [];
-    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
-        });
-      }
-    }
-    const userContent = this.convertUserMessageToContent(userMessage);
-    messages.push({ role: "user", content: userContent });
-    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 }
-      };
-      if (this.enableThinkingPhase && hasTools) {
-        yield {
-          type: "thinking_start" /* THINKING_START */,
-          timestamp: Date.now(),
-          data: {}
-        };
-        const toolsDescription = this.generateToolsDescription(mcpTools);
-        const thinkingSystemPrompt = `## \u4F60\u7684\u89D2\u8272
-\u4F60\u73B0\u5728\u662F\u300C\u5185\u90E8\u601D\u8003\u8005\u300D\uFF0C\u8FD9\u6BB5\u601D\u8003\u7528\u6237\u770B\u4E0D\u5230\u3002
-\u4F60\u7684\u4EFB\u52A1\u662F\uFF1A\u5206\u6790\u5F53\u524D\u72B6\u6001\uFF0C\u5224\u65AD\u4E0B\u4E00\u6B65\u8BE5\u505A\u4EC0\u4E48\u3002
-
-## \u53C2\u8003\u4FE1\u606F\uFF08\u53EF\u80FD\u5305\u542B\u91CD\u8981\u914D\u7F6E\u5982\u8BA4\u8BC1\u4FE1\u606F\uFF09
-${this.systemPrompt}
-
-## \u53EF\u7528\u5DE5\u5177
-${toolsDescription}
-${this.thinkingPhasePrompt}`;
-        const summarizedMessages = messages.slice(1).map((msg) => {
-          if (msg.role === "tool" && Array.isArray(msg.content)) {
-            const summarizedContent = msg.content.map((item) => {
-              if (item.type === "tool-result") {
-                return {
-                  ...item,
-                  result: this.summarizeToolResult(item.toolName, item.result)
-                };
-              }
-              return item;
-            });
-            return { ...msg, content: summarizedContent };
-          }
-          return msg;
-        });
-        const thinkingMessages = [
-          {
-            role: "system",
-            content: thinkingSystemPrompt
-          },
-          ...summarizedMessages
-        ];
-        const thinkingOptions = {
-          model: this.model,
-          messages: thinkingMessages,
-          maxTokens: this.thinkingMaxTokens
-          // 不传 tools，强制 AI 输出文本思考
-        };
-        thinkingOptions.providerOptions = {
-          openai: {
-            enable_thinking: false
-          }
-        };
-        const thinkingStream = streamText(thinkingOptions);
-        let thinkingContent = "";
-        for await (const chunk of thinkingStream.fullStream) {
-          if (chunk.type === "text-delta") {
-            thinkingContent += chunk.textDelta;
-            yield {
-              type: "thinking_delta" /* THINKING_DELTA */,
-              timestamp: Date.now(),
-              data: { content: chunk.textDelta }
-            };
-          }
-        }
-        yield {
-          type: "thinking_end" /* THINKING_END */,
-          timestamp: Date.now(),
-          data: {}
-        };
-        if (thinkingContent) {
-          messages.push({
-            role: "assistant",
-            content: `[\u5185\u90E8\u51B3\u7B56]
-${thinkingContent}`
-          });
-        }
-      }
-      const streamOptions = {
-        model: this.model,
-        messages,
-        tools: hasTools ? tools : void 0,
-        maxSteps: 1
-      };
-      if (this.enableThinkingPhase) {
-        streamOptions.providerOptions = {
-          openai: {
-            enable_thinking: false
-          }
-        };
-      }
-      const stream = streamText(streamOptions);
-      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;
-      }
-      const toolResults = [];
-      for (const toolCall of toolCalls) {
-        yield {
-          type: "tool_executing" /* TOOL_EXECUTING */,
-          timestamp: Date.now(),
-          data: {
-            toolName: toolCall.toolName,
-            toolCallId: toolCall.toolCallId,
-            toolArgs: toolCall.args
-          }
-        };
-      }
-      let hasImmediateResult = false;
-      if (this.parallelToolCalls && toolCalls.length > 1) {
-        const executePromises = toolCalls.map(async (toolCall) => {
-          const toolStartTime = Date.now();
-          let result;
-          let isError = false;
-          try {
-            result = await this.mcpManager.callTool(toolCall.toolName, toolCall.args);
-          } catch (error) {
-            result = error instanceof Error ? error.message : String(error);
-            isError = true;
-          }
-          const duration = Date.now() - toolStartTime;
-          return {
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            args: toolCall.args,
-            result,
-            isError,
-            duration
-          };
-        });
-        const results = await Promise.all(executePromises);
-        for (const r of results) {
-          yield {
-            type: "tool_result" /* TOOL_RESULT */,
-            timestamp: Date.now(),
-            data: {
-              toolName: r.toolName,
-              toolResult: r.result,
-              toolCallId: r.toolCallId,
-              duration: r.duration,
-              isError: r.isError
-            }
+  parseStreamChunk(line) {
+    try {
+      const data = JSON.parse(line);
+      const choice = data.choices[0];
+      const delta = choice?.delta;
+      if (delta?.content) {
+        return { type: "text", content: delta.content };
+      }
+      if (delta?.tool_calls) {
+        const tc = delta.tool_calls[0];
+        if (tc.id && tc.function?.name && (!this.pendingToolCall || this.pendingToolCall.id !== tc.id)) {
+          const result = this.flushPendingToolCall();
+          this.pendingToolCall = {
+            id: tc.id,
+            name: tc.function.name,
+            arguments: tc.function.arguments || ""
           };
-          if (!r.isError && this.matchImmediateResult(r.result)) {
-            hasImmediateResult = true;
-            yield {
-              type: "immediate_result" /* IMMEDIATE_RESULT */,
-              timestamp: Date.now(),
-              data: {
-                toolName: r.toolName,
-                toolCallId: r.toolCallId,
-                immediateResult: r.result
-              }
-            };
+          if (this.isToolCallComplete(this.pendingToolCall)) {
+            return this.flushPendingToolCall();
           }
-          toolResults.push({
-            toolCallId: r.toolCallId,
-            toolName: r.toolName,
-            result: r.result,
-            isError: r.isError,
-            duration: r.duration
-          });
-          toolCallRecords.push({
-            name: r.toolName,
-            arguments: r.args,
-            result: r.result,
-            duration: r.duration
-          });
+          return result;
         }
-      } else {
-        for (const toolCall of toolCalls) {
-          const toolName = toolCall.toolName;
-          const toolArgs = toolCall.args;
-          const toolCallId = toolCall.toolCallId;
-          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;
+        if (this.pendingToolCall && tc.function?.arguments) {
+          this.pendingToolCall.arguments += tc.function.arguments;
+          if (this.isToolCallComplete(this.pendingToolCall)) {
+            return this.flushPendingToolCall();
           }
-          const duration = Date.now() - toolStartTime;
-          yield {
-            type: "tool_result" /* TOOL_RESULT */,
-            timestamp: Date.now(),
-            data: {
-              toolName,
-              toolResult: result,
-              toolCallId,
-              duration,
-              isError
-            }
-          };
-          if (!isError && this.matchImmediateResult(result)) {
-            hasImmediateResult = true;
-            yield {
-              type: "immediate_result" /* IMMEDIATE_RESULT */,
-              timestamp: Date.now(),
-              data: {
-                toolName,
-                toolCallId,
-                immediateResult: result
-              }
-            };
-          }
-          toolResults.push({
-            toolCallId,
-            toolName,
-            result,
-            isError,
-            duration
-          });
-          toolCallRecords.push({
-            name: toolName,
-            arguments: toolArgs,
-            result,
-            duration
-          });
         }
       }
-      if (hasImmediateResult) {
-        yield {
-          type: "iteration_end" /* ITERATION_END */,
-          timestamp: Date.now(),
-          data: { iteration }
-        };
-        break;
+      if (choice?.finish_reason && this.pendingToolCall) {
+        return this.flushPendingToolCall();
       }
-      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;
-  immediateResultMatchers;
-  parallelToolCalls;
-  // PromptBasedAgent 本身通过 prompt 实现思考，此配置保留以保持接口一致
-  enableThinkingPhase;
-  constructor(model, mcpManager, options = {}) {
-    this.model = model;
-    this.mcpManager = mcpManager;
-    this.systemPrompt = options.systemPrompt || "";
-    this.maxIterations = options.maxIterations || 10;
-    this.immediateResultMatchers = options.immediateResultMatchers || [];
-    this.parallelToolCalls = options.parallelToolCalls ?? true;
-    this.enableThinkingPhase = options.enableThinkingPhase ?? false;
-  }
-  /**
-   * 检查工具返回结果是否匹配即时结果匹配器
-   * @param result 工具返回的结果
-   * @returns 如果匹配返回 true，否则返回 false
-   */
-  matchImmediateResult(result) {
-    const debug = process.env.DEBUG_MCPLINK === "true";
-    if (!this.immediateResultMatchers.length) {
-      if (debug) console.log("[MCPLink] \u26A0\uFE0F \u672A\u914D\u7F6E\u5373\u65F6\u7ED3\u679C\u5339\u914D\u5668");
-      return false;
-    }
-    let resultObj = null;
-    if (typeof result === "string") {
-      try {
-        const parsed = JSON.parse(result);
-        if (typeof parsed === "object" && parsed !== null) {
-          resultObj = parsed;
-          if (debug) console.log("[MCPLink] \u{1F50D} \u89E3\u6790\u5DE5\u5177\u7ED3\u679C\u4E3A\u5BF9\u8C61:", Object.keys(parsed));
-        }
-      } catch {
-        if (debug) console.log("[MCPLink] \u26A0\uFE0F \u5DE5\u5177\u7ED3\u679C\u4E0D\u662F\u6709\u6548 JSON");
-      }
-    } else if (typeof result === "object" && result !== null) {
-      resultObj = result;
-      if (debug) console.log("[MCPLink] \u{1F50D} \u5DE5\u5177\u7ED3\u679C\u662F\u5BF9\u8C61:", Object.keys(result));
-    }
-    if (!resultObj) {
-      if (debug) console.log("[MCPLink] \u26A0\uFE0F \u65E0\u6CD5\u89E3\u6790\u5DE5\u5177\u7ED3\u679C\u4E3A\u5BF9\u8C61");
-      return false;
-    }
-    for (const matcher of this.immediateResultMatchers) {
-      let matched = true;
-      for (const [key, value] of Object.entries(matcher)) {
-        if (resultObj[key] !== value) {
-          matched = false;
-          break;
-        }
-      }
-      if (matched) {
-        if (debug) console.log("[MCPLink] \u2705 \u5373\u65F6\u7ED3\u679C\u5339\u914D\u6210\u529F:", JSON.stringify(matcher));
-        return true;
+      if (choice?.finish_reason) {
+        return { type: "done" };
       }
+      return null;
+    } catch {
+      return null;
     }
-    if (debug) console.log("[MCPLink] \u274C \u5373\u65F6\u7ED3\u679C\u672A\u5339\u914D\uFF0C\u671F\u671B:", JSON.stringify(this.immediateResultMatchers), "\u5B9E\u9645:", JSON.stringify(resultObj));
-    return false;
   }
   /**
-   * 生成工具列表描述
+   * 转换消息格式
    */
-  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;
+  convertMessage(msg) {
+    if (msg.role !== "tool") {
+      const result = {
+        role: msg.role,
+        content: msg.content
+      };
+      if (msg.role === "assistant" && msg.toolCalls) {
+        result.tool_calls = msg.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.name,
+            arguments: JSON.stringify(tc.arguments)
           }
-        }
-        content = content.slice(0, MAX_ASSISTANT_MESSAGE_LENGTH) + "...";
-      }
-      return { role: msg.role, content: content.trim() || msg.content.slice(0, 500) };
-    });
-  }
-  /**
-   * 将 UserMessage 转换为 Vercel AI SDK 的消息内容格式
-   */
-  convertUserMessageToContent(message) {
-    if (typeof message === "string") {
-      return message;
-    }
-    return message.map((part) => {
-      switch (part.type) {
-        case "text":
-          return { type: "text", text: part.text };
-        case "image":
-          return { type: "image", image: part.image, mimeType: part.mimeType };
-        case "file":
-          return { type: "file", data: part.data, mimeType: part.mimeType };
-        default:
-          return { type: "text", text: "" };
-      }
-    });
-  }
-  /**
-   * 从 UserMessage 提取纯文本内容（用于日志等）
-   */
-  extractTextFromMessage(message) {
-    if (typeof message === "string") {
-      return message;
-    }
-    return message.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-  }
-  /**
-   * 流式对话（支持多模态消息）
-   */
-  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 });
+        }));
       }
+      return result;
     }
-    const userContent = this.convertUserMessageToContent(userMessage);
-    messages.push({ role: "user", content: userContent });
-    const textPreview = this.extractTextFromMessage(userMessage);
-    console.log(`[PromptBasedAgent] \u{1F4DD} \u7528\u6237\u6D88\u606F: "${textPreview.slice(0, 50)}${textPreview.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 }
+    if (msg.toolResults && msg.toolResults.length > 0) {
+      const tr = msg.toolResults[0];
+      return {
+        role: "tool",
+        tool_call_id: tr.toolCallId,
+        content: typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result)
       };
-      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
-          // 禁用遥测以减少开销
-        },
-        // 禁用 Qwen 思考模式 - 使用 openai 命名空间因为这是通过 OpenAI 兼容接口调用
-        providerOptions: {
-          openai: {
-            enable_thinking: 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 (!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 }
-        };
-        if (!isError && this.matchImmediateResult(result)) {
-          yield {
-            type: "immediate_result" /* IMMEDIATE_RESULT */,
-            timestamp: Date.now(),
-            data: {
-              toolName: toolCall.name,
-              toolCallId,
-              immediateResult: result
-            }
-          };
-          yield { type: "iteration_end" /* ITERATION_END */, timestamp: Date.now(), data: { iteration } };
-          yield {
-            type: "complete" /* COMPLETE */,
-            timestamp: Date.now(),
-            data: { totalDuration: Date.now() - startTime, totalIterations: iteration }
-          };
-          return;
-        }
-        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 }
+    return {
+      role: "user",
+      content: msg.content
     };
   }
 };
+var openaiAdapter = new OpenAIAdapter();
 
 // 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;
+  mcpManager;
+  httpClient;
+  adapter;
   initialized = false;
-  detectedNativeSupport;
   constructor(config) {
     this.config = config;
-    this.model = config.model;
     this.mcpManager = new MCPManager();
+    this.httpClient = new HttpClient();
+    if (typeof config.adapter === "string") {
+      this.adapter = this.getAdapterByType(config.adapter);
+    } else if (config.adapter) {
+      this.adapter = config.adapter;
+    } else {
+      this.adapter = openaiAdapter;
+    }
     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,
-      immediateResultMatchers: config.immediateResultMatchers,
-      parallelToolCalls: config.parallelToolCalls,
-      enableThinkingPhase: config.enableThinkingPhase,
-      thinkingPhasePrompt: config.thinkingPhasePrompt,
-      thinkingMaxTokens: config.thinkingMaxTokens
-    });
-    this.promptBasedAgent = new PromptBasedAgent(this.model, this.mcpManager, {
-      systemPrompt: config.systemPrompt,
-      maxIterations: config.maxIterations,
-      immediateResultMatchers: config.immediateResultMatchers,
-      parallelToolCalls: config.parallelToolCalls,
-      enableThinkingPhase: config.enableThinkingPhase,
-      thinkingPhasePrompt: config.thinkingPhasePrompt,
-      thinkingMaxTokens: config.thinkingMaxTokens
-    });
-    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;
-    }
+    if (this.initialized) return;
     await this.mcpManager.startAll();
     this.initialized = true;
   }
@@ -1872,132 +612,349 @@ var MCPLink = class {
     this.initialized = false;
   }
   /**
-   * 发起对话
-   */
-  async chat(message, callbacks) {
+   * 对话 - 极简设计
+   *
+   * 流程：
+   * 1. 发送消息给 AI
+   * 2. AI 返回文本/工具调用
+   * 3. 如果有工具调用，执行 MCP 工具
+   * 4. 返回结果（包括新的消息历史，用户可选择是否继续）
+   *
+   * 用户需要自己：
+   * - 维护 messages 历史
+   * - 处理流式响应（通过 onStream）
+   * - 决定是否继续迭代（如果返回了 toolCalls）
+   */
+  async chat(options) {
     if (!this.initialized) {
       await this.initialize();
     }
-    return this.agent.chat(message, callbacks);
+    const startTime = Date.now();
+    const maxIterations = this.config.maxIterations ?? 10;
+    let iterations = 0;
+    let messages = [...options.messages];
+    const mcpTools = this.mcpManager.getAllTools();
+    const tools = mcpTools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema
+    }));
+    while (iterations < maxIterations) {
+      iterations++;
+      const response = options.stream !== false ? await this.streamChat(messages, tools, options.onStream) : await this.singleChat(messages, tools);
+      if (!response.toolCalls || response.toolCalls.length === 0) {
+        messages.push({
+          role: "assistant",
+          content: response.content
+        });
+        return {
+          content: response.content,
+          messages,
+          iterations,
+          duration: Date.now() - startTime
+        };
+      }
+      const assistantMessage = {
+        role: "assistant",
+        content: response.content,
+        toolCalls: response.toolCalls
+      };
+      const toolResults = [];
+      for (const tc of response.toolCalls) {
+        let result;
+        let isError = false;
+        try {
+          result = await this.mcpManager.callTool(tc.name, tc.arguments);
+        } catch (error) {
+          result = error instanceof Error ? error.message : String(error);
+          isError = true;
+        }
+        toolResults.push({
+          toolCallId: tc.id,
+          toolName: tc.name,
+          result,
+          isError
+        });
+      }
+      messages.push(assistantMessage);
+      messages.push({
+        role: "tool",
+        content: "",
+        toolResults
+      });
+    }
+    return {
+      content: messages[messages.length - 1]?.content || "",
+      messages,
+      iterations,
+      duration: Date.now() - startTime
+    };
+  }
+  /**
+   * 单次 AI 调用（非流式）
+   */
+  async singleChat(messages, tools) {
+    const response = await this.httpClient.chat(
+      this.config.ai,
+      this.adapter,
+      messages,
+      tools
+    );
+    return {
+      content: response.content,
+      toolCalls: response.toolCalls
+    };
+  }
+  /**
+   * 流式 AI 调用
+   */
+  async streamChat(messages, tools, onStream) {
+    let content = "";
+    const toolCalls = [];
+    for await (const event of this.httpClient.streamChat(
+      this.config.ai,
+      this.adapter,
+      messages,
+      tools
+    )) {
+      const shouldContinue = onStream?.(event);
+      if (shouldContinue === false) {
+        break;
+      }
+      switch (event.type) {
+        case "text":
+          content += event.content;
+          break;
+        case "tool_call":
+          toolCalls.push(event.toolCall);
+          break;
+        case "error":
+          throw event.error;
+      }
+    }
+    return {
+      content,
+      toolCalls: toolCalls.length ? toolCalls : void 0
+    };
   }
   /**
-   * 流式对话
-   * @param message 用户消息（支持字符串或多模态数组）
-   * @param options 可选参数
-   * @param options.allowedTools 允许使用的工具名称列表
-   * @param options.history 历史消息列表
+   * 流式对话 - 公共方法
+   * 直接发起流式请求并返回结果
    */
-  async *chatStream(message, options) {
+  async chatStream(messages, onStream) {
     if (!this.initialized) {
       await this.initialize();
     }
-    if (this.detectedNativeSupport) {
-      yield* this.agent.chatStream(message, options);
-    } else {
-      yield* this.promptBasedAgent.chatStream(message, options);
+    const startTime = Date.now();
+    const mcpTools = this.mcpManager.getAllTools();
+    const tools = mcpTools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema
+    }));
+    const response = await this.streamChat(messages, tools, onStream);
+    if (response.toolCalls && response.toolCalls.length > 0) {
+      const toolResults = [];
+      for (const tc of response.toolCalls) {
+        let result;
+        let isError = false;
+        try {
+          result = await this.mcpManager.callTool(tc.name, tc.arguments);
+        } catch (error) {
+          result = error instanceof Error ? error.message : String(error);
+          isError = true;
+        }
+        toolResults.push({
+          toolCallId: tc.id,
+          toolName: tc.name,
+          result,
+          isError
+        });
+      }
+      const assistantMessage = {
+        role: "assistant",
+        content: response.content,
+        toolCalls: response.toolCalls
+      };
+      messages.push(assistantMessage);
+      messages.push({
+        role: "tool",
+        content: "",
+        toolResults
+      });
+      return {
+        content: response.content,
+        messages,
+        iterations: 1,
+        duration: Date.now() - startTime
+      };
     }
+    messages.push({
+      role: "assistant",
+      content: response.content
+    });
+    return {
+      content: response.content,
+      messages,
+      iterations: 1,
+      duration: Date.now() - startTime
+    };
   }
   /**
-   * 获取当前使用的模式
+   * 根据类型获取适配器
    */
-  getToolCallingMode() {
-    return this.detectedNativeSupport ? "native" : "prompt-based";
+  getAdapterByType(type) {
+    switch (type) {
+      case "openai":
+        return openaiAdapter;
+      default:
+        throw new Error(`Unknown adapter type: ${type}`);
+    }
   }
   // ============ 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,
-      immediateResultMatchers: this.config.immediateResultMatchers,
-      parallelToolCalls: this.config.parallelToolCalls,
-      enableThinkingPhase: this.config.enableThinkingPhase,
-      thinkingPhasePrompt: this.config.thinkingPhasePrompt,
-      thinkingMaxTokens: this.config.thinkingMaxTokens
-    });
-    this.promptBasedAgent = new PromptBasedAgent(this.model, this.mcpManager, {
-      systemPrompt: prompt,
-      maxIterations: this.config.maxIterations,
-      immediateResultMatchers: this.config.immediateResultMatchers,
-      parallelToolCalls: this.config.parallelToolCalls,
-      enableThinkingPhase: this.config.enableThinkingPhase,
-      thinkingPhasePrompt: this.config.thinkingPhasePrompt,
-      thinkingMaxTokens: this.config.thinkingMaxTokens
-    });
+};
+
+// src/standard-stream.ts
+async function* toStandardStream(rawStream, options) {
+  let iteration = 0;
+  options.maxIterations ?? 10;
+  const startTime = Date.now();
+  let hasTextStarted = false;
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  for await (const event of rawStream) {
+    const shouldContinue = options.onRawEvent?.(event);
+    if (shouldContinue === false) break;
+    switch (event.type) {
+      case "text":
+        if (!hasTextStarted) {
+          hasTextStarted = true;
+          yield { type: "text_start" };
+        }
+        if (event.content) {
+          yield { type: "text_delta", content: event.content };
+        }
+        break;
+      case "tool_call": {
+        if (hasTextStarted) {
+          hasTextStarted = false;
+          yield { type: "text_end" };
+        }
+        const tc = event.toolCall;
+        pendingToolCalls.set(tc.id, { ...tc, argsBuffer: "" });
+        yield {
+          type: "tool_call_start",
+          toolCallId: tc.id,
+          toolName: tc.name,
+          toolArgs: tc.arguments
+        };
+        yield {
+          type: "tool_executing",
+          toolCallId: tc.id,
+          toolName: tc.name
+        };
+        const toolStartTime = Date.now();
+        let result;
+        let isError = false;
+        try {
+          result = await options.executeTool(tc.name, tc.arguments);
+        } catch (error) {
+          result = error instanceof Error ? error.message : String(error);
+          isError = true;
+        }
+        const duration = Date.now() - toolStartTime;
+        yield {
+          type: "tool_result",
+          toolCallId: tc.id,
+          toolName: tc.name,
+          toolResult: result,
+          duration,
+          isError
+        };
+        pendingToolCalls.delete(tc.id);
+        break;
+      }
+      case "done":
+        if (hasTextStarted) {
+          hasTextStarted = false;
+          yield { type: "text_end" };
+        }
+        break;
+      case "error":
+        yield { type: "error", error: event.error };
+        return;
+    }
   }
-  /**
-   * 更新 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,
-      immediateResultMatchers: this.config.immediateResultMatchers,
-      parallelToolCalls: this.config.parallelToolCalls,
-      enableThinkingPhase: this.config.enableThinkingPhase,
-      thinkingPhasePrompt: this.config.thinkingPhasePrompt,
-      thinkingMaxTokens: this.config.thinkingMaxTokens
-    });
-    this.promptBasedAgent = new PromptBasedAgent(this.model, this.mcpManager, {
-      systemPrompt: this.config.systemPrompt,
-      maxIterations: this.config.maxIterations,
-      immediateResultMatchers: this.config.immediateResultMatchers,
-      parallelToolCalls: this.config.parallelToolCalls,
-      enableThinkingPhase: this.config.enableThinkingPhase,
-      thinkingPhasePrompt: this.config.thinkingPhasePrompt,
-      thinkingMaxTokens: this.config.thinkingMaxTokens
-    });
+  if (hasTextStarted) {
+    yield { type: "text_end" };
   }
-};
+  yield {
+    type: "complete",
+    totalIterations: iteration,
+    totalDuration: Date.now() - startTime
+  };
+}
+async function collectStandardResponse(stream) {
+  const response = {
+    content: "",
+    toolCalls: [],
+    iterations: 0,
+    duration: 0
+  };
+  const toolCallMap = /* @__PURE__ */ new Map();
+  for await (const event of stream) {
+    switch (event.type) {
+      case "text_delta":
+        response.content += event.content;
+        break;
+      case "tool_call_start": {
+        const tc = {
+          id: event.toolCallId,
+          name: event.toolName,
+          arguments: event.toolArgs
+        };
+        response.toolCalls.push(tc);
+        toolCallMap.set(event.toolCallId, tc);
+        break;
+      }
+      case "tool_result": {
+        const tc = toolCallMap.get(event.toolCallId);
+        if (tc) {
+          tc.result = event.toolResult;
+          tc.duration = event.duration;
+          tc.isError = event.isError;
+        }
+        break;
+      }
+      case "complete":
+        response.iterations = event.totalIterations;
+        response.duration = event.totalDuration;
+        break;
+    }
+  }
+  return response;
+}
 
-export { Agent, DEFAULT_SYSTEM_PROMPT, DEFAULT_THINKING_PHASE_PROMPT, MCPLink, MCPLinkEventType, MCPManager, PromptBasedAgent };
+export { HttpClient, MCPLink, MCPManager, OpenAIAdapter, collectStandardResponse, openaiAdapter, toStandardStream };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map