@huyooo/ai-chat-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1554 @@
+import { GoogleGenAI } from '@google/genai';
+
+// src/agent.ts
+
+// src/types.ts
+var AVAILABLE_MODELS = [
+  {
+    provider: "doubao",
+    model: "doubao-seed-1-6-251015",
+    displayName: "\u8C46\u5305 Seed",
+    supportsTools: true,
+    supportsWebSearch: true,
+    supportedThinkingModes: ["enabled", "disabled"]
+  },
+  {
+    provider: "deepseek",
+    model: "deepseek-v3-1-terminus",
+    displayName: "DeepSeek V3",
+    supportsTools: true,
+    supportsWebSearch: true,
+    // 注意：火山引擎托管的 DeepSeek V3.1 不支持 auto 模式
+    supportedThinkingModes: ["enabled", "disabled"]
+  },
+  // 通义千问 - 混合思考模式（默认不开启）
+  {
+    provider: "qwen",
+    model: "qwen3-max-preview",
+    displayName: "\u901A\u4E49\u5343\u95EE Max",
+    supportsTools: true,
+    supportsWebSearch: true,
+    supportedThinkingModes: ["enabled", "disabled"]
+  },
+  {
+    provider: "qwen",
+    model: "qwen-plus",
+    displayName: "\u901A\u4E49\u5343\u95EE Plus",
+    supportsTools: true,
+    supportsWebSearch: true,
+    supportedThinkingModes: ["enabled", "disabled"]
+  },
+  // Gemini 3 - Google 最新推理模型
+  {
+    provider: "gemini",
+    model: "gemini-3-pro-preview",
+    displayName: "Gemini 3 Pro",
+    supportsTools: true,
+    supportsWebSearch: true,
+    // 支持 Google Search grounding
+    supportedThinkingModes: ["enabled", "disabled"]
+    // thinking_level: high/low
+  },
+  // OpenRouter - Claude Opus 4.5
+  {
+    provider: "openrouter",
+    model: "anthropic/claude-opus-4.5",
+    displayName: "Claude Opus 4.5",
+    supportsTools: true,
+    supportsWebSearch: true,
+    // 通过 :online 后缀或 plugins 支持
+    supportedThinkingModes: ["enabled", "disabled"]
+    // Claude 扩展思考
+  }
+];
+
+// src/tools.ts
+var DEFAULT_WORKING_DIR = process.cwd();
+function createToolDefinitions(workingDir = DEFAULT_WORKING_DIR) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: "execute_command",
+        description: `\u6267\u884C shell \u547D\u4EE4\u6765\u5B8C\u6210\u6587\u4EF6\u7BA1\u7406\u4EFB\u52A1\u3002\u652F\u6301\uFF1Als\u3001find\u3001cat\u3001head\u3001tail\u3001du\u3001file \u7B49\u547D\u4EE4\u3002\u9ED8\u8BA4\u5DE5\u4F5C\u76EE\u5F55\uFF1A${workingDir}`,
+        parameters: {
+          type: "object",
+          properties: {
+            command: { type: "string", description: "\u8981\u6267\u884C\u7684 shell \u547D\u4EE4" },
+            workingDir: { type: "string", description: "\u5DE5\u4F5C\u76EE\u5F55\uFF08\u53EF\u9009\uFF09" }
+          },
+          required: ["command"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "analyze_image",
+        description: `\u5206\u6790\u56FE\u7247\u5185\u5BB9\u3002\u53EF\u4EE5\u8BC6\u522B\u56FE\u7247\u4E2D\u7684\u7269\u4F53\u3001\u573A\u666F\u3001\u6587\u5B57\u3001\u4EBA\u7269\u7B49\u3002\u652F\u6301\u7684\u56FE\u7247\u683C\u5F0F\uFF1Ajpg\u3001jpeg\u3001png\u3001gif\u3001webp`,
+        parameters: {
+          type: "object",
+          properties: {
+            imagePath: { type: "string", description: "\u56FE\u7247\u6587\u4EF6\u7684\u5B8C\u6574\u8DEF\u5F84" },
+            question: { type: "string", description: "\u5173\u4E8E\u56FE\u7247\u7684\u95EE\u9898\uFF08\u53EF\u9009\uFF09" }
+          },
+          required: ["imagePath"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "generate_image",
+        description: `\u6839\u636E\u6587\u5B57\u63CF\u8FF0\u751F\u6210\u56FE\u7247\u3002\u53EF\u4EE5\u751F\u6210\u5404\u79CD\u98CE\u683C\u7684\u56FE\u7247\u3002`,
+        parameters: {
+          type: "object",
+          properties: {
+            prompt: { type: "string", description: "\u56FE\u7247\u63CF\u8FF0" },
+            outputPath: { type: "string", description: "\u8F93\u51FA\u56FE\u7247\u7684\u4FDD\u5B58\u8DEF\u5F84\uFF08\u53EF\u9009\uFF09" }
+          },
+          required: ["prompt"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "analyze_video",
+        description: `\u5206\u6790\u89C6\u9891\u5185\u5BB9\u3002\u53EF\u4EE5\u8BC6\u522B\u89C6\u9891\u4E2D\u7684\u573A\u666F\u3001\u52A8\u4F5C\u3001\u7269\u4F53\u7B49\u3002\u652F\u6301\u7684\u89C6\u9891\u683C\u5F0F\uFF1Amp4\u3001mov\u3001avi\u3001webm`,
+        parameters: {
+          type: "object",
+          properties: {
+            videoPath: { type: "string", description: "\u89C6\u9891\u6587\u4EF6\u7684\u5B8C\u6574\u8DEF\u5F84" },
+            question: { type: "string", description: "\u5173\u4E8E\u89C6\u9891\u7684\u95EE\u9898\uFF08\u53EF\u9009\uFF09" }
+          },
+          required: ["videoPath"]
+        }
+      }
+    }
+  ];
+}
+var DANGEROUS_COMMANDS = [
+  "rm -rf /",
+  "rm -rf ~",
+  "format",
+  "mkfs",
+  "dd if=",
+  "shutdown",
+  "reboot",
+  "sudo rm",
+  "sudo format"
+];
+function isDangerousCommand(command) {
+  const lowerCommand = command.toLowerCase().trim();
+  return DANGEROUS_COMMANDS.some(
+    (dangerous) => lowerCommand.includes(dangerous.toLowerCase())
+  );
+}
+function createDefaultToolExecutor(workingDir = DEFAULT_WORKING_DIR) {
+  return {
+    async executeCommand(command, cwd) {
+      if (isDangerousCommand(command)) {
+        return { success: false, error: "\u8BE5\u547D\u4EE4\u88AB\u5B89\u5168\u7B56\u7565\u963B\u6B62" };
+      }
+      try {
+        const { exec } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(exec);
+        const { stdout, stderr } = await execAsync(command, {
+          cwd: cwd || workingDir,
+          timeout: 3e4,
+          maxBuffer: 1024 * 1024 * 10,
+          shell: "/bin/sh"
+        });
+        return { success: true, output: (stdout || stderr || "").trim() };
+      } catch (error) {
+        return { success: false, error: String(error) };
+      }
+    },
+    async readFile(path) {
+      const fs = await import('fs/promises');
+      return fs.readFile(path);
+    },
+    async writeFile(path, data) {
+      const fs = await import('fs/promises');
+      await fs.writeFile(path, data);
+    },
+    async readDirectory(path) {
+      const fs = await import('fs/promises');
+      return fs.readdir(path);
+    }
+  };
+}
+
+// src/constants.ts
+var DEFAULT_ARK_URL = "https://ark.cn-beijing.volces.com/api/v3";
+var DEFAULT_QWEN_NATIVE_URL = "https://dashscope.aliyuncs.com/api/v1";
+var DEFAULT_OPENROUTER_URL = "https://openrouter.ai/api/v1";
+var DEFAULT_MODEL = "doubao-seed-1-6-251015";
+var GEMINI_IMAGE_MODEL = "gemini-2.0-flash";
+var GEMINI_IMAGE_GEN_MODEL = "gemini-3-pro-image-preview";
+var MAX_ITERATIONS = 10;
+var MODE_PROMPTS = {
+  agent: `\u4F60\u53EF\u4EE5\u4F7F\u7528\u5DE5\u5177\u5B8C\u6210\u4EFB\u52A1\u3002\u76F4\u63A5\u8C03\u7528\u5DE5\u5177\uFF0C\u5B8C\u6210\u540E\u7B80\u6D01\u603B\u7ED3\u7ED3\u679C\u3002`,
+  plan: `\u5206\u6790\u9700\u6C42\u5E76\u5236\u5B9A\u6267\u884C\u8BA1\u5212\uFF0C\u4EE5 Markdown \u683C\u5F0F\u8F93\u51FA\uFF0C\u7B49\u5F85\u786E\u8BA4\u540E\u6267\u884C\u3002`,
+  ask: `\u76F4\u63A5\u56DE\u7B54\u95EE\u9898\uFF0C\u4E0D\u77E5\u9053\u5C31\u8BF4\u4E0D\u77E5\u9053\u3002`
+};
+
+// src/providers/ark.ts
+var ARK_MODELS = [
+  "doubao-seed-1-6-251015",
+  "deepseek-v3-1-terminus"
+];
+var MODEL_CAPABILITIES = {
+  "doubao-seed-1-6-251015": {
+    supportsTools: true,
+    supportsWebSearch: true,
+    supportsThinking: true,
+    supportedThinkingModes: ["enabled", "disabled"]
+  },
+  "deepseek-v3-1-terminus": {
+    supportsTools: true,
+    supportsWebSearch: true,
+    supportsThinking: true,
+    supportedThinkingModes: ["enabled", "disabled"]
+  }
+};
+var DEFAULT_CAPABILITIES = {
+  supportsTools: true,
+  supportsWebSearch: true,
+  supportsThinking: true,
+  supportedThinkingModes: ["enabled", "disabled"]
+};
+function convertToResponsesApiTools(tools) {
+  return tools.map((tool) => {
+    const t = tool;
+    return {
+      type: "function",
+      name: t.function.name,
+      description: t.function.description,
+      parameters: t.function.parameters
+    };
+  });
+}
+function convertToResponsesApiInput(systemPrompt, history, message) {
+  const input = [];
+  input.push({
+    role: "system",
+    content: systemPrompt
+  });
+  for (const msg of history) {
+    if (msg.role === "user") {
+      input.push({
+        role: "user",
+        content: [{ type: "input_text", text: msg.content }]
+      });
+    } else if (msg.role === "assistant") {
+      input.push({
+        role: "developer",
+        content: `[\u4E0A\u4E00\u8F6EAI\u56DE\u590D]: ${msg.content}`
+      });
+    }
+  }
+  input.push({
+    role: "user",
+    content: [{ type: "input_text", text: message }]
+  });
+  return input;
+}
+var ArkProvider = class {
+  name = "ark";
+  supportedModels = ARK_MODELS;
+  apiKey;
+  apiUrl;
+  enableCaching;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.apiUrl = config.apiUrl || DEFAULT_ARK_URL;
+    this.enableCaching = config.enableCaching ?? false;
+  }
+  supportsModel(model) {
+    return ARK_MODELS.includes(model) || model.startsWith("doubao-") || model.startsWith("deepseek-");
+  }
+  getModelCapabilities(model) {
+    return MODEL_CAPABILITIES[model] || DEFAULT_CAPABILITIES;
+  }
+  /**
+   * 聊天入口 - 统一使用 Responses API
+   */
+  async *chat(message, model, options, context) {
+    const showThinking = options.thinkingMode === "enabled";
+    const enableWebSearch = options.enableWebSearch === true;
+    if (showThinking) {
+      yield { type: "thinking", data: { content: "\u6B63\u5728\u601D\u8003...", isComplete: false } };
+    }
+    let searchStarted = false;
+    const tools = [];
+    if (enableWebSearch) {
+      tools.push({
+        type: "web_search",
+        max_keyword: 5,
+        limit: 20
+      });
+    }
+    if (options.mode !== "ask") {
+      const functionTools = createToolDefinitions(context.workingDir);
+      tools.push(...convertToResponsesApiTools(functionTools));
+    }
+    const input = convertToResponsesApiInput(context.systemPrompt, context.history, message);
+    let iterations = 0;
+    let finalText = "";
+    let thinkingComplete = !showThinking;
+    let searchComplete = !enableWebSearch;
+    let searchResults = [];
+    let hasExecutedTools = false;
+    const pendingFunctionCalls = /* @__PURE__ */ new Map();
+    while (iterations < MAX_ITERATIONS) {
+      if (context.signal.aborted) {
+        yield { type: "error", data: "\u8BF7\u6C42\u5DF2\u53D6\u6D88" };
+        return;
+      }
+      iterations++;
+      try {
+        const requestBody = {
+          model,
+          stream: true,
+          max_output_tokens: 32768,
+          input
+        };
+        if (tools.length > 0) {
+          requestBody.tools = tools;
+        }
+        const effectiveThinkingMode = hasExecutedTools ? "disabled" : options.thinkingMode;
+        if (effectiveThinkingMode) {
+          const thinkingConfig = {
+            type: effectiveThinkingMode
+          };
+          if (effectiveThinkingMode === "enabled" && options.thinkingBudget) {
+            thinkingConfig.budget_tokens = options.thinkingBudget;
+          }
+          requestBody.thinking = thinkingConfig;
+        }
+        if (this.enableCaching) {
+          requestBody.caching = { type: "enabled" };
+        }
+        const response = await fetch(`${this.apiUrl}/responses`, {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(requestBody),
+          signal: context.signal
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`Responses API \u9519\u8BEF: ${response.status} - ${errorText}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+          throw new Error("\u65E0\u6CD5\u83B7\u53D6\u54CD\u5E94\u6D41");
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let currentFunctionCallId = null;
+        let needsFunctionExecution = false;
+        while (true) {
+          if (context.signal.aborted) {
+            reader.cancel();
+            yield { type: "error", data: "\u8BF7\u6C42\u5DF2\u53D6\u6D88" };
+            return;
+          }
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (!line.startsWith("data:")) continue;
+            const data = line.slice(5).trim();
+            if (data === "[DONE]") continue;
+            try {
+              const event = JSON.parse(data);
+              switch (event.type) {
+                // 添加输出项
+                case "response.output_item.added": {
+                  const item = event.item;
+                  if (item?.type === "web_search_call") {
+                    if (!searchStarted) {
+                      searchStarted = true;
+                      yield {
+                        type: "search_start",
+                        data: { query: item.query || message }
+                      };
+                    }
+                  } else if (item?.type === "function_call") {
+                    const callId = item.id || `call_${Date.now()}`;
+                    currentFunctionCallId = callId;
+                    pendingFunctionCalls.set(callId, {
+                      name: item.name || "",
+                      arguments: ""
+                    });
+                  }
+                  break;
+                }
+                // 函数名称
+                case "response.function_call.name": {
+                  if (currentFunctionCallId) {
+                    const call = pendingFunctionCalls.get(currentFunctionCallId);
+                    if (call) {
+                      call.name = event.name || call.name;
+                    }
+                  }
+                  break;
+                }
+                // 函数参数增量
+                case "response.function_call_arguments.delta": {
+                  if (currentFunctionCallId) {
+                    const call = pendingFunctionCalls.get(currentFunctionCallId);
+                    if (call) {
+                      call.arguments += event.delta || "";
+                    }
+                  }
+                  break;
+                }
+                // 函数调用完成
+                case "response.function_call_arguments.done":
+                case "response.output_item.done": {
+                  const item = event.item;
+                  if (item?.type === "function_call" && item.name) {
+                    const callId = item.id || currentFunctionCallId || `call_${Date.now()}`;
+                    pendingFunctionCalls.set(callId, {
+                      name: item.name,
+                      arguments: item.arguments || pendingFunctionCalls.get(callId)?.arguments || "{}"
+                    });
+                    needsFunctionExecution = true;
+                  }
+                  if (item?.type === "web_search_call" && item.action?.query) {
+                  }
+                  break;
+                }
+                // 搜索进行中（官方事件类型）
+                case "response.web_search_call.in_progress": {
+                  break;
+                }
+                // 搜索完成（官方事件类型）
+                case "response.web_search_call.completed": {
+                  break;
+                }
+                // 搜索引用（流式收集，最后统一发送）
+                case "response.output_text.annotation.added": {
+                  const annotation = event.annotation;
+                  const isUrlCitation = annotation?.type === "url_citation" || annotation?.type === "citation" || annotation?.url;
+                  if (isUrlCitation && annotation?.url) {
+                    const exists = searchResults.some((r) => r.url === annotation.url);
+                    if (!exists) {
+                      searchResults.push({
+                        title: annotation.title || annotation.text || "",
+                        url: annotation.url,
+                        snippet: annotation.summary || annotation.snippet || ""
+                      });
+                      console.log("[ARK] \u6536\u96C6\u5230\u641C\u7D22\u5F15\u7528:", annotation.url);
+                    }
+                  }
+                  break;
+                }
+                // 文本输出增量
+                case "response.output_text.delta": {
+                  if (!thinkingComplete) {
+                    thinkingComplete = true;
+                    yield { type: "thinking", data: { content: "", isComplete: true } };
+                  }
+                  const delta = event.delta || "";
+                  finalText += delta;
+                  yield { type: "text_delta", data: delta };
+                  break;
+                }
+                // 深度思考内容增量
+                case "response.reasoning_summary_text.delta": {
+                  yield {
+                    type: "thinking",
+                    data: { content: event.delta || "", isComplete: false }
+                  };
+                  break;
+                }
+                // 深度思考完成
+                case "response.reasoning_summary_text.done": {
+                  thinkingComplete = true;
+                  yield {
+                    type: "thinking",
+                    data: { content: "", isComplete: true }
+                  };
+                  break;
+                }
+                // 响应完成
+                case "response.done": {
+                  if (searchStarted && !searchComplete) {
+                    searchComplete = true;
+                    console.log("[ARK] \u53D1\u9001\u641C\u7D22\u7ED3\u679C:", searchResults.length, "\u6761");
+                    yield { type: "search_result", data: { results: searchResults, isComplete: true } };
+                  }
+                  break;
+                }
+                default: {
+                  if (event.type && !event.type.startsWith("response.created") && !event.type.startsWith("rate_limits")) {
+                  }
+                }
+              }
+            } catch {
+            }
+          }
+        }
+        if (needsFunctionExecution && pendingFunctionCalls.size > 0) {
+          for (const [callId, call] of pendingFunctionCalls) {
+            if (!call.name) continue;
+            let args;
+            try {
+              args = JSON.parse(call.arguments || "{}");
+            } catch {
+              yield { type: "error", data: `\u5DE5\u5177\u53C2\u6570\u89E3\u6790\u5931\u8D25: ${call.arguments}` };
+              input.push({
+                type: "function_call_output",
+                call_id: callId,
+                output: "\u53C2\u6570\u89E3\u6790\u9519\u8BEF"
+              });
+              continue;
+            }
+            yield { type: "tool_call", data: { name: call.name, args } };
+            const result = await context.executeTool(call.name, args);
+            yield { type: "tool_result", data: { name: call.name, result } };
+            input.push({
+              type: "function_call_output",
+              call_id: callId,
+              output: result
+            });
+            hasExecutedTools = true;
+          }
+          pendingFunctionCalls.clear();
+          continue;
+        }
+        break;
+      } catch (error) {
+        if (context.signal.aborted) {
+          yield { type: "error", data: "\u8BF7\u6C42\u5DF2\u53D6\u6D88" };
+        } else {
+          yield { type: "error", data: String(error) };
+        }
+        break;
+      }
+    }
+    if (!thinkingComplete) {
+      yield { type: "thinking", data: { content: "", isComplete: true } };
+    }
+    if (searchStarted && !searchComplete) {
+      yield { type: "search_result", data: { results: searchResults, isComplete: true } };
+    }
+    context.history.push({ role: "user", content: message });
+    context.history.push({ role: "assistant", content: finalText || "\u5B8C\u6210" });
+    yield { type: "text", data: finalText };
+    yield { type: "done", data: finalText };
+  }
+};
+
+// src/providers/qwen.ts
+var QWEN_MODELS = [
+  "qwen3-max-preview",
+  "qwen-plus"
+];
+var MODEL_CAPABILITIES2 = {
+  "qwen3-max-preview": {
+    supportsTools: true,
+    supportsWebSearch: true,
+    supportsThinking: true,
+    supportedThinkingModes: ["enabled", "disabled"]
+  },
+  "qwen-plus": {
+    supportsTools: true,
+    supportsWebSearch: true,
+    supportsThinking: true,
+    supportedThinkingModes: ["enabled", "disabled"]
+  }
+};
+var DEFAULT_CAPABILITIES2 = {
+  supportsTools: true,
+  supportsWebSearch: true,
+  supportsThinking: true,
+  supportedThinkingModes: ["enabled", "disabled"]
+};
+var QwenProvider = class {
+  name = "qwen";
+  supportedModels = QWEN_MODELS;
+  apiKey;
+  apiUrl;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.apiUrl = config.apiUrl || DEFAULT_QWEN_NATIVE_URL;
+  }
+  supportsModel(model) {
+    return QWEN_MODELS.includes(model) || model.startsWith("qwen");
+  }
+  getModelCapabilities(model) {
+    return MODEL_CAPABILITIES2[model] || DEFAULT_CAPABILITIES2;
+  }
+  async *chat(message, model, options, context) {
+    const showThinking = options.thinkingMode === "enabled";
+    const enableSearch = options.enableWebSearch === true;
+    if (showThinking) {
+      yield { type: "thinking", data: { content: "\u6B63\u5728\u601D\u8003...", isComplete: false } };
+    }
+    if (enableSearch) {
+      yield { type: "search_start", data: { query: message } };
+    }
+    const tools = options.mode === "ask" ? [] : createToolDefinitions(context.workingDir).map((t) => ({
+      type: "function",
+      function: {
+        name: t.function.name,
+        description: t.function.description,
+        parameters: t.function.parameters
+      }
+    }));
+    const messages = [
+      { role: "system", content: context.systemPrompt },
+      ...context.history,
+      { role: "user", content: message }
+    ];
+    let iterations = 0;
+    let finalText = "";
+    let thinkingContent = "";
+    let thinkingComplete = !showThinking;
+    let searchComplete = !enableSearch;
+    let searchResults = [];
+    let hasExecutedTools = false;
+    while (iterations < MAX_ITERATIONS) {
+      if (context.signal.aborted) {
+        yield { type: "error", data: "\u8BF7\u6C42\u5DF2\u53D6\u6D88" };
+        return;
+      }
+      iterations++;
+      try {
+        const toolCallsMap = /* @__PURE__ */ new Map();
+        const effectiveEnableThinking = hasExecutedTools ? false : showThinking;
+        for await (const event of this.callDashScopeStream(
+          model,
+          messages,
+          tools,
+          { enableSearch, enableThinking: effectiveEnableThinking, thinkingBudget: options.thinkingBudget },
+          context.signal
+        )) {
+          const choice = event.output?.choices?.[0];
+          if (event.output?.search_info?.search_results && !searchComplete) {
+            searchResults = event.output.search_info.search_results;
+            searchComplete = true;
+            yield {
+              type: "search_result",
+              data: {
+                results: searchResults.map((r) => ({
+                  title: r.title,
+                  url: r.url,
+                  snippet: r.snippet || ""
+                })),
+                isComplete: true
+              }
+            };
+          }
+          if (!choice) continue;
+          const msg = choice.message;
+          if (msg.reasoning_content && !thinkingComplete) {
+            thinkingContent += msg.reasoning_content;
+            yield { type: "thinking", data: { content: msg.reasoning_content, isComplete: false } };
+          }
+          if (msg.content) {
+            if (!thinkingComplete) {
+              thinkingComplete = true;
+              yield { type: "thinking", data: { content: "", isComplete: true } };
+            }
+            finalText += msg.content;
+            yield { type: "text_delta", data: msg.content };
+          }
+          if (msg.tool_calls?.length) {
+            for (const tc of msg.tool_calls) {
+              const index = tc.index ?? 0;
+              const existing = toolCallsMap.get(index);
+              if (existing) {
+                if (tc.function?.arguments) {
+                  existing.arguments += tc.function.arguments;
+                }
+                if (tc.function?.name) {
+                  existing.name = tc.function.name;
+                }
+                if (tc.id) {
+                  existing.id = tc.id;
+                }
+              } else {
+                toolCallsMap.set(index, {
+                  id: tc.id || `call_${Date.now()}_${index}`,
+                  name: tc.function?.name || "",
+                  arguments: tc.function?.arguments || ""
+                });
+              }
+            }
+          }
+          if (choice.finish_reason === "stop" || choice.finish_reason === "length" || choice.finish_reason === "tool_calls") {
+            break;
+          }
+        }
+        const currentToolCalls = Array.from(toolCallsMap.values()).filter((tc) => tc.name);
+        if (!thinkingComplete) {
+          thinkingComplete = true;
+          yield { type: "thinking", data: { content: "", isComplete: true } };
+        }
+        if (currentToolCalls.length > 0) {
+          messages.push({
+            role: "assistant",
+            content: finalText || "",
+            tool_calls: currentToolCalls.map((tc) => ({
+              id: tc.id,
+              type: "function",
+              function: {
+                name: tc.name,
+                arguments: tc.arguments
+              }
+            }))
+          });
+          for (const tc of currentToolCalls) {
+            const name = tc.name;
+            let args;
+            try {
+              args = JSON.parse(tc.arguments);
+            } catch {
+              yield { type: "error", data: `\u5DE5\u5177\u53C2\u6570\u89E3\u6790\u5931\u8D25: ${tc.arguments}` };
+              messages.push({
+                role: "tool",
+                tool_call_id: tc.id,
+                content: `\u53C2\u6570\u89E3\u6790\u9519\u8BEF`
+              });
+              continue;
+            }
+            yield { type: "tool_call", data: { name, args } };
+            const result = await context.executeTool(name, args);
+            yield { type: "tool_result", data: { name, result } };
+            messages.push({
+              role: "tool",
+              tool_call_id: tc.id,
+              content: result
+            });
+            hasExecutedTools = true;
+          }
+          finalText = "";
+          continue;
+        }
+        break;
+      } catch (error) {
+        if (context.signal.aborted) {
+          yield { type: "error", data: "\u8BF7\u6C42\u5DF2\u53D6\u6D88" };
+        } else {
+          yield { type: "error", data: String(error) };
+        }
+        break;
+      }
+    }
+    if (!searchComplete) {
+      yield { type: "search_result", data: { results: [], isComplete: true } };
+    }
+    context.history.push({ role: "user", content: message });
+    context.history.push({
+      role: "assistant",
+      content: finalText || "\u5B8C\u6210",
+      reasoning_content: thinkingContent || void 0
+    });
+    yield { type: "text", data: finalText };
+    yield { type: "done", data: finalText };
+  }
+  /** 调用 DashScope API (流式) */
+  async *callDashScopeStream(model, messages, tools, options, signal) {
+    const formattedMessages = messages.map((m) => {
+      const msg = {
+        role: m.role,
+        content: m.content
+      };
+      if (m.tool_call_id) {
+        msg.tool_call_id = m.tool_call_id;
+      }
+      if (m.tool_calls?.length) {
+        msg.tool_calls = m.tool_calls;
+      }
+      return msg;
+    });
+    const requestBody = {
+      model,
+      input: { messages: formattedMessages },
+      parameters: {
+        result_format: "message",
+        incremental_output: true,
+        max_tokens: 32768
+      }
+    };
+    const params = requestBody.parameters;
+    if (options.enableThinking) {
+      params.enable_thinking = true;
+      if (options.thinkingBudget) {
+        params.thinking_budget = options.thinkingBudget;
+      }
+    }
+    if (options.enableSearch) {
+      params.enable_search = true;
+      params.search_options = {
+        enable_source: true,
+        enable_citation: true,
+        search_strategy: "turbo"
+      };
+    }
+    if (tools.length > 0) {
+      params.tools = tools;
+    }
+    const response = await fetch(`${this.apiUrl}/services/aigc/text-generation/generation`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        "X-DashScope-SSE": "enable"
+      },
+      body: JSON.stringify(requestBody),
+      signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`DashScope API \u9519\u8BEF: ${response.status} - ${errorText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("\u65E0\u6CD5\u83B7\u53D6\u54CD\u5E94\u6D41");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("data:")) {
+          const data = line.slice(5).trim();
+          if (data && data !== "[DONE]") {
+            try {
+              yield JSON.parse(data);
+            } catch {
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/providers/gemini.ts
+var GEMINI_MODELS = [
+  "gemini-3-pro-preview"
+];
+var MODEL_CAPABILITIES3 = {
+  "gemini-3-pro-preview": {
+    supportsTools: true,
+    supportsWebSearch: true,
+    supportsThinking: true,
+    supportedThinkingModes: ["enabled", "disabled"]
+  }
+};
+var DEFAULT_CAPABILITIES3 = {
+  supportsTools: true,
+  supportsWebSearch: true,
+  supportsThinking: true,
+  supportedThinkingModes: ["enabled", "disabled"]
+};
+var GeminiProvider = class {
+  name = "gemini";
+  supportedModels = GEMINI_MODELS;
+  geminiClient = null;
+  apiKey;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+  }
+  /** 懒加载 Gemini 客户端 */
+  async getClient() {
+    if (!this.geminiClient) {
+      const { GoogleGenAI: GoogleGenAI2 } = await import('@google/genai');
+      this.geminiClient = new GoogleGenAI2({ apiKey: this.apiKey });
+    }
+    return this.geminiClient;
+  }
+  supportsModel(model) {
+    return GEMINI_MODELS.includes(model) || model.startsWith("gemini-");
+  }
+  getModelCapabilities(model) {
+    return MODEL_CAPABILITIES3[model] || DEFAULT_CAPABILITIES3;
+  }
+  async *chat(message, model, options, context) {
+    const geminiClient = await this.getClient();
+    const showThinking = options.thinkingMode === "enabled";
+    const tools = options.mode === "ask" ? [] : createToolDefinitions(context.workingDir);
+    const enableWebSearch = options.enableWebSearch === true && tools.length === 0;
+    if (showThinking) {
+      yield { type: "thinking", data: { content: "\u6B63\u5728\u601D\u8003...", isComplete: false } };
+    }
+    if (enableWebSearch) {
+      yield { type: "search_start", data: { query: message } };
+    }
+    const geminiMessages = [
+      { role: "user", parts: [{ text: context.systemPrompt }] },
+      { role: "model", parts: [{ text: "\u597D\u7684\uFF0C\u6211\u4F1A\u6309\u7167\u4F60\u7684\u6307\u793A\u884C\u4E8B\u3002" }] },
+      ...this.convertToGeminiMessages(context.history),
+      { role: "user", parts: [{ text: message }] }
+    ];
+    let iterations = 0;
+    let finalText = "";
+    let thinkingComplete = !showThinking;
+    let searchComplete = !enableWebSearch;
+    while (iterations < MAX_ITERATIONS) {
+      if (context.signal.aborted) {
+        yield { type: "error", data: "\u8BF7\u6C42\u5DF2\u53D6\u6D88" };
+        return;
+      }
+      iterations++;
+      try {
+        const generateConfig = {
+          thinkingConfig: {
+            thinkingLevel: options.thinkingMode === "enabled" ? "high" : "low",
+            // 启用思考摘要返回（Gemini 3 支持）
+            includeThoughts: showThinking
+          }
+        };
+        if (tools.length > 0) {
+          generateConfig.tools = [{
+            functionDeclarations: this.convertToGeminiFunctions(tools)
+          }];
+        } else if (enableWebSearch) {
+          generateConfig.tools = [{ googleSearch: {} }];
+        }
+        const response = await geminiClient.models.generateContent({
+          model,
+          contents: geminiMessages,
+          config: generateConfig
+        });
+        const candidate = response.candidates?.[0];
+        if (!candidate) {
+          yield { type: "error", data: "\u65E0\u54CD\u5E94" };
+          break;
+        }
+        const rawCandidate = response.candidates?.[0];
+        const groundingMetadata = rawCandidate?.groundingMetadata;
+        if (groundingMetadata && !searchComplete) {
+          searchComplete = true;
+          const searchResults = (groundingMetadata.groundingChunks || []).filter((chunk) => chunk.web).map((chunk) => ({
+            url: chunk.web.uri,
+            title: chunk.web.title,
+            snippet: ""
+          }));
+          yield {
+            type: "search_result",
+            data: {
+              results: searchResults,
+              queries: groundingMetadata.webSearchQueries,
+              isComplete: true
+            }
+          };
+        }
+        const parts = candidate.content?.parts || [];
+        let hasToolCall = false;
+        for (const part of parts) {
+          const extendedPart = part;
+          if (extendedPart.thought && part.text) {
+            yield { type: "thinking", data: { content: part.text, isComplete: false } };
+            continue;
+          }
+          if (part.text && !extendedPart.thought) {
+            if (!thinkingComplete) {
+              thinkingComplete = true;
+              yield { type: "thinking", data: { content: "", isComplete: true } };
+            }
+            finalText += part.text;
+            yield { type: "text_delta", data: part.text };
+          }
+          if (part.functionCall && part.functionCall.name) {
+            hasToolCall = true;
+            const name = part.functionCall.name;
+            const args = part.functionCall.args || {};
+            const thoughtSignature = part.thoughtSignature;
+            yield { type: "tool_call", data: { name, args } };
+            const result = await context.executeTool(name, args);
+            yield { type: "tool_result", data: { name, result } };
+            const modelPart = { functionCall: { name, args } };
+            if (thoughtSignature) {
+              modelPart.thoughtSignature = thoughtSignature;
+            }
+            geminiMessages.push({
+              role: "model",
+              parts: [modelPart]
+            });
+            geminiMessages.push({
+              role: "user",
+              parts: [{ functionResponse: { name, response: { result } } }]
+            });
+          }
+        }
+        if (!hasToolCall) {
+          break;
+        }
+      } catch (error) {
+        if (context.signal.aborted) {
+          yield { type: "error", data: "\u8BF7\u6C42\u5DF2\u53D6\u6D88" };
+        } else {
+          yield { type: "error", data: String(error) };
+        }
+        break;
+      }
+    }
+    if (!thinkingComplete) {
+      yield { type: "thinking", data: { content: "", isComplete: true } };
+    }
+    if (!searchComplete) {
+      yield { type: "search_result", data: { results: [], isComplete: true } };
+    }
+    context.history.push({ role: "user", content: message });
+    context.history.push({ role: "assistant", content: finalText || "\u5B8C\u6210" });
+    yield { type: "text", data: finalText };
+    yield { type: "done", data: finalText };
+  }
+  /** 转换消息格式为 Gemini 格式 */
+  convertToGeminiMessages(messages) {
+    return messages.map((msg) => ({
+      role: msg.role === "assistant" ? "model" : msg.role,
+      parts: [{ text: msg.content }]
+    }));
+  }
+  /** 转换工具定义为 Gemini functionDeclarations 格式 */
+  convertToGeminiFunctions(tools) {
+    return tools.map((tool) => {
+      const t = tool;
+      return {
+        name: t.function.name,
+        description: t.function.description,
+        parameters: t.function.parameters
+      };
+    });
+  }
+};
+
+// src/providers/openrouter.ts
+var OPENROUTER_MODELS = [
+  "anthropic/claude-opus-4.5"
+];
+var MODEL_CAPABILITIES4 = {
+  "anthropic/claude-opus-4.5": {
+    supportsTools: true,
+    supportsWebSearch: true,
+    supportsThinking: true,
+    supportedThinkingModes: ["enabled", "disabled"]
+  }
+};
+var DEFAULT_CAPABILITIES4 = {
+  supportsTools: true,
+  supportsWebSearch: true,
+  supportsThinking: false,
+  supportedThinkingModes: ["disabled"]
+};
+var OpenRouterProvider = class {
+  name = "openrouter";
+  supportedModels = OPENROUTER_MODELS;
+  apiKey;
+  apiUrl;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.apiUrl = config.apiUrl || DEFAULT_OPENROUTER_URL;
+  }
+  supportsModel(model) {
+    return OPENROUTER_MODELS.includes(model) || model.includes("/");
+  }
+  getModelCapabilities(model) {
+    return MODEL_CAPABILITIES4[model] || DEFAULT_CAPABILITIES4;
+  }
+  /** 检查模型是否支持 Extended Thinking */
+  supportsThinking(model) {
+    return model.includes("claude-opus-4.5") || model === "anthropic/claude-opus-4.5";
+  }
+  async *chat(message, model, options, context) {
+    const enableThinking = options.thinkingMode === "enabled" && this.supportsThinking(model);
+    const enableWebSearch = options.enableWebSearch === true;
+    if (enableThinking) {
+      yield { type: "thinking", data: { content: "", isComplete: false } };
+    }
+    if (enableWebSearch) {
+      yield { type: "search_start", data: { query: message } };
+    }
+    const tools = options.mode === "ask" ? [] : createToolDefinitions(context.workingDir);
+    const messages = [
+      { role: "system", content: context.systemPrompt },
+      ...context.history,
+      { role: "user", content: message }
+    ];
+    let iterations = 0;
+    let finalText = "";
+    let thinkingContent = "";
+    let thinkingComplete = !enableThinking;
+    let searchComplete = !enableWebSearch;
+    while (iterations < MAX_ITERATIONS) {
+      if (context.signal.aborted) {
+        yield { type: "error", data: "\u8BF7\u6C42\u5DF2\u53D6\u6D88" };
+        return;
+      }
+      iterations++;
+      try {
+        const response = await this.callOpenRouter(
+          model,
+          messages,
+          tools,
+          enableWebSearch,
+          enableThinking,
+          context.signal
+        );
+        const choice = response.choices?.[0];
+        if (!choice) {
+          yield { type: "error", data: "\u65E0\u54CD\u5E94" };
+          break;
+        }
+        const responseMessage = choice.message;
+        const finishReason = choice.finish_reason;
+        if (responseMessage.reasoning && !thinkingComplete) {
+          thinkingContent = responseMessage.reasoning;
+          yield { type: "thinking", data: { content: responseMessage.reasoning, isComplete: false } };
+        }
+        if (enableThinking && !thinkingComplete && responseMessage.content) {
+          thinkingComplete = true;
+          yield { type: "thinking", data: { content: "", isComplete: true } };
+        }
+        if (enableWebSearch && !searchComplete && responseMessage.annotations?.length) {
+          searchComplete = true;
+          const searchResults = responseMessage.annotations.filter((a) => a.type === "url_citation").map((a) => ({
+            url: a.url_citation.url,
+            title: a.url_citation.title || "",
+            snippet: a.url_citation.content || ""
+          }));
+          yield {
+            type: "search_result",
+            data: {
+              results: searchResults,
+              isComplete: true
+            }
+          };
+        } else if (enableWebSearch && !searchComplete && iterations === 1) {
+          searchComplete = true;
+          yield { type: "search_result", data: { results: [], isComplete: true } };
+        }
+        if (finishReason === "tool_calls" && responseMessage.tool_calls?.length) {
+          messages.push(responseMessage);
+          for (const toolCall of responseMessage.tool_calls) {
+            const name = toolCall.function.name;
+            let args;
+            try {
+              args = JSON.parse(toolCall.function.arguments);
+            } catch {
+              yield { type: "error", data: `\u5DE5\u5177\u53C2\u6570\u89E3\u6790\u5931\u8D25` };
+              messages.push({
+                role: "tool",
+                tool_call_id: toolCall.id,
+                content: `\u53C2\u6570\u89E3\u6790\u9519\u8BEF: ${toolCall.function.arguments}`
+              });
+              continue;
+            }
+            yield { type: "tool_call", data: { name, args } };
+            const result = await context.executeTool(name, args);
+            yield { type: "tool_result", data: { name, result } };
+            messages.push({
+              role: "tool",
+              tool_call_id: toolCall.id,
+              content: result
+            });
+          }
+          if (responseMessage.content) {
+            finalText += responseMessage.content + "\n";
+            yield { type: "text_delta", data: responseMessage.content };
+          }
+          continue;
+        }
+        if (responseMessage.content || finishReason === "stop" || finishReason === "end_turn") {
+          if (responseMessage.content) {
+            finalText += responseMessage.content;
+            yield { type: "text_delta", data: responseMessage.content };
+          }
+          break;
+        }
+        break;
+      } catch (error) {
+        if (context.signal.aborted) {
+          yield { type: "error", data: "\u8BF7\u6C42\u5DF2\u53D6\u6D88" };
+        } else {
+          yield { type: "error", data: String(error) };
+        }
+        break;
+      }
+    }
+    if (!thinkingComplete) {
+      yield { type: "thinking", data: { content: "", isComplete: true } };
+    }
+    if (!searchComplete) {
+      yield { type: "search_result", data: { results: [], isComplete: true } };
+    }
+    context.history.push({ role: "user", content: message });
+    context.history.push({
+      role: "assistant",
+      content: finalText || "\u5B8C\u6210",
+      reasoning_content: thinkingContent || void 0
+    });
+    yield { type: "text", data: finalText };
+    yield { type: "done", data: finalText };
+  }
+  /** 调用 OpenRouter API */
+  async callOpenRouter(model, messages, tools, enableWebSearch, enableThinking, signal) {
+    const requestBody = {
+      model,
+      messages,
+      max_tokens: 32768
+    };
+    if (enableThinking && this.supportsThinking(model)) {
+      requestBody.reasoning = {
+        effort: "high",
+        exclude: false
+        // 包含推理过程
+      };
+    }
+    if (tools.length > 0) {
+      requestBody.tools = tools;
+    }
+    if (enableWebSearch) {
+      requestBody.plugins = [
+        {
+          id: "web",
+          max_results: 5
+        }
+      ];
+    }
+    const response = await fetch(`${this.apiUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        "HTTP-Referer": "https://github.com/huyooo/ai-chat",
+        "X-Title": "AI Chat Agent"
+      },
+      body: JSON.stringify(requestBody),
+      signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`OpenRouter API \u9519\u8BEF: ${response.status} - ${errorText}`);
+    }
+    return response.json();
+  }
+};
+
+// src/gemini.ts
+function getMimeType(ext) {
+  const types = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp"
+  };
+  return types[ext] || "image/jpeg";
+}
+function getVideoMimeType(ext) {
+  const types = {
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".avi": "video/x-msvideo",
+    ".webm": "video/webm"
+  };
+  return types[ext] || "video/mp4";
+}
+async function analyzeImage(geminiClient, imagePath, question) {
+  try {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    const imageData = await fs.readFile(imagePath);
+    const base64 = imageData.toString("base64");
+    const ext = path.extname(imagePath).toLowerCase();
+    const mimeType = getMimeType(ext);
+    const response = await geminiClient.models.generateContent({
+      model: GEMINI_IMAGE_MODEL,
+      contents: [{
+        role: "user",
+        parts: [
+          { text: question || "\u8BF7\u8BE6\u7EC6\u63CF\u8FF0\u8FD9\u5F20\u56FE\u7247\u7684\u5185\u5BB9" },
+          { inlineData: { mimeType, data: base64 } }
+        ]
+      }]
+    });
+    return response.text || "\u65E0\u6CD5\u5206\u6790\u56FE\u7247";
+  } catch (error) {
+    return `\u56FE\u7247\u5206\u6790\u5931\u8D25: ${error}`;
+  }
+}
+async function generateImage(geminiClient, workingDir, prompt, outputPath) {
+  try {
+    const response = await geminiClient.models.generateContent({
+      model: GEMINI_IMAGE_GEN_MODEL,
+      contents: [{ role: "user", parts: [{ text: prompt }] }]
+    });
+    for (const part of response.candidates?.[0]?.content?.parts || []) {
+      if (part.inlineData) {
+        const imageData = Buffer.from(part.inlineData.data, "base64");
+        const mimeType = part.inlineData.mimeType || "image/png";
+        const ext = mimeType === "image/jpeg" ? ".jpg" : mimeType === "image/webp" ? ".webp" : ".png";
+        if (outputPath) {
+          const fs = await import('fs/promises');
+          await fs.writeFile(outputPath, imageData);
+          return `\u56FE\u7247\u5DF2\u751F\u6210\u5E76\u4FDD\u5B58\u5230: ${outputPath}`;
+        } else {
+          const savePath = `${workingDir}/generated_${Date.now()}${ext}`;
+          const fs = await import('fs/promises');
+          await fs.writeFile(savePath, imageData);
+          return `\u56FE\u7247\u5DF2\u751F\u6210\u5E76\u4FDD\u5B58\u5230: ${savePath}`;
+        }
+      }
+    }
+    return "\u56FE\u7247\u751F\u6210\u5931\u8D25";
+  } catch (error) {
+    return `\u56FE\u7247\u751F\u6210\u5931\u8D25: ${error}`;
+  }
+}
+async function analyzeVideo(geminiClient, videoPath, question) {
+  try {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    const videoData = await fs.readFile(videoPath);
+    const base64 = videoData.toString("base64");
+    const ext = path.extname(videoPath).toLowerCase();
+    const mimeType = getVideoMimeType(ext);
+    const response = await geminiClient.models.generateContent({
+      model: GEMINI_IMAGE_MODEL,
+      contents: [{
+        role: "user",
+        parts: [
+          { text: question || "\u8BF7\u8BE6\u7EC6\u63CF\u8FF0\u8FD9\u4E2A\u89C6\u9891\u7684\u5185\u5BB9" },
+          { inlineData: { mimeType, data: base64 } }
+        ]
+      }]
+    });
+    return response.text || "\u65E0\u6CD5\u5206\u6790\u89C6\u9891";
+  } catch (error) {
+    return `\u89C6\u9891\u5206\u6790\u5931\u8D25: ${error}`;
+  }
+}
+
+// src/agent.ts
+var HybridAgent = class {
+  config;
+  providers = /* @__PURE__ */ new Map();
+  geminiClient;
+  toolExecutor;
+  conversationHistory = [];
+  abortController = null;
+  constructor(config, toolExecutor) {
+    this.config = {
+      arkApiKey: config.arkApiKey,
+      arkApiUrl: config.arkApiUrl || DEFAULT_ARK_URL,
+      qwenApiKey: config.qwenApiKey || "",
+      qwenApiUrl: config.qwenApiUrl || DEFAULT_QWEN_NATIVE_URL,
+      openrouterApiKey: config.openrouterApiKey || "",
+      openrouterApiUrl: config.openrouterApiUrl || DEFAULT_OPENROUTER_URL,
+      geminiApiKey: config.geminiApiKey,
+      workingDir: config.workingDir || process.cwd()
+    };
+    this.geminiClient = new GoogleGenAI({ apiKey: this.config.geminiApiKey });
+    this.toolExecutor = toolExecutor || createDefaultToolExecutor(this.config.workingDir);
+    this.initializeProviders();
+  }
+  /**
+   * 初始化所有 Provider
+   */
+  initializeProviders() {
+    if (this.config.arkApiKey) {
+      this.providers.set("ark", new ArkProvider({
+        apiKey: this.config.arkApiKey,
+        apiUrl: this.config.arkApiUrl
+      }));
+    }
+    if (this.config.qwenApiKey) {
+      this.providers.set("qwen", new QwenProvider({
+        apiKey: this.config.qwenApiKey,
+        apiUrl: this.config.qwenApiUrl
+      }));
+    }
+    if (this.config.geminiApiKey) {
+      this.providers.set("gemini", new GeminiProvider({
+        apiKey: this.config.geminiApiKey
+      }));
+    }
+    if (this.config.openrouterApiKey) {
+      this.providers.set("openrouter", new OpenRouterProvider({
+        apiKey: this.config.openrouterApiKey,
+        apiUrl: this.config.openrouterApiUrl
+      }));
+    }
+  }
+  /**
+   * 判断模型提供商
+   */
+  getModelProvider(model) {
+    const lowerModel = model.toLowerCase();
+    if (lowerModel.startsWith("qwen")) {
+      return "qwen";
+    }
+    if (lowerModel.startsWith("gemini")) {
+      return "gemini";
+    }
+    if (lowerModel.includes("/")) {
+      return "openrouter";
+    }
+    return "ark";
+  }
+  /**
+   * 获取 Provider
+   */
+  getProvider(model) {
+    const providerName = this.getModelProvider(model);
+    return this.providers.get(providerName);
+  }
+  /**
+   * 构建系统提示词
+   */
+  buildSystemPrompt(options) {
+    const modePrompt = MODE_PROMPTS[options.mode || "agent"];
+    const toolsInfo = options.mode === "ask" ? "" : `
+\u53EF\u7528\u5DE5\u5177\uFF1A
+1. execute_command - \u6267\u884C Shell \u547D\u4EE4
+2. analyze_image - \u5206\u6790\u56FE\u7247\u5185\u5BB9
+3. generate_image - \u751F\u6210\u56FE\u7247
+4. analyze_video - \u5206\u6790\u89C6\u9891\u5185\u5BB9`;
+    return `${modePrompt}
+
+\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF1A${this.config.workingDir}
+${toolsInfo}`;
+  }
+  /**
+   * 获取默认深度思考模式（统一为 disabled）
+   */
+  getDefaultThinkingMode() {
+    return "disabled";
+  }
+  /**
+   * 执行工具
+   */
+  async executeTool(name, args) {
+    switch (name) {
+      case "execute_command": {
+        const result = await this.toolExecutor.executeCommand(
+          args.command,
+          args.workingDir
+        );
+        return result.success ? result.output || "\u6267\u884C\u6210\u529F" : `\u9519\u8BEF: ${result.error}`;
+      }
+      case "analyze_image":
+        return await analyzeImage(
+          this.geminiClient,
+          args.imagePath,
+          args.question
+        );
+      case "generate_image":
+        return await generateImage(
+          this.geminiClient,
+          this.config.workingDir,
+          args.prompt,
+          args.outputPath
+        );
+      case "analyze_video":
+        return await analyzeVideo(
+          this.geminiClient,
+          args.videoPath,
+          args.question
+        );
+      default:
+        return `\u672A\u77E5\u5DE5\u5177: ${name}`;
+    }
+  }
+  /**
+   * 聊天入口
+   * 
+   * 使用 Provider 模式路由请求到对应的模型提供商
+   */
+  async *chat(message, options = {}, images) {
+    this.abortController = new AbortController();
+    const signal = this.abortController.signal;
+    const model = options.model || DEFAULT_MODEL;
+    const provider = this.getProvider(model);
+    if (!provider) {
+      const providerName = this.getModelProvider(model);
+      yield { type: "error", data: `\u7F3A\u5C11 ${providerName} Provider \u7684 API Key` };
+      return;
+    }
+    const thinkingMode = options.thinkingMode ?? this.getDefaultThinkingMode();
+    const optionsWithThinking = { ...options, thinkingMode };
+    const systemPrompt = this.buildSystemPrompt(optionsWithThinking);
+    const context = {
+      history: this.conversationHistory,
+      systemPrompt,
+      workingDir: this.config.workingDir,
+      executeTool: this.executeTool.bind(this),
+      signal
+    };
+    try {
+      yield* provider.chat(message, model, optionsWithThinking, context);
+    } finally {
+      this.abortController = null;
+    }
+  }
+  /**
+   * 中断当前请求
+   */
+  abort() {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+  /**
+   * 清空对话历史
+   */
+  clearHistory() {
+    this.conversationHistory = [];
+  }
+  /**
+   * 获取对话历史
+   */
+  getHistory() {
+    return [...this.conversationHistory];
+  }
+  /**
+   * 设置工作目录
+   */
+  setWorkingDir(dir) {
+    this.config.workingDir = dir;
+  }
+  /**
+   * 获取当前配置
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * 获取模型能力
+   */
+  getModelCapabilities(model) {
+    const provider = this.getProvider(model);
+    return provider?.getModelCapabilities(model);
+  }
+  /**
+   * 获取所有支持的模型
+   */
+  getSupportedModels() {
+    return AVAILABLE_MODELS;
+  }
+};
+
+export { AVAILABLE_MODELS, ArkProvider, GeminiProvider, HybridAgent, OpenRouterProvider, QwenProvider, createDefaultToolExecutor, createToolDefinitions };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map