@huyooo/ai-chat-core 0.1.4 → 0.1.7

package/dist/index.cjs

@@ -4,132 +4,366 @@ var genai = require('@google/genai');
 
 // src/agent.ts
 
+// src/constants.ts
+var DEFAULT_ARK_URL = "https://ark.cn-beijing.volces.com/api/v3";
+var DEFAULT_QWEN_URL = "https://dashscope.aliyuncs.com/api/v1";
+var DEFAULT_QWEN_NATIVE_URL = "https://dashscope.aliyuncs.com/api/v1";
+var DEFAULT_OPENROUTER_URL = "https://openrouter.ai/api/v1";
+var DOUBAO_SEED_1_8 = {
+  id: "doubao-seed-1-8-251215"};
+var DOUBAO_SEED_1_6 = {
+  id: "doubao-seed-1-6-250615",
+  displayName: "\u8C46\u5305 Seed 1.6",
+  provider: "\u8C46\u5305"
+};
+var DOUBAO_SEED_1_6_LATEST = {
+  id: "doubao-seed-1-6-251015"};
+var DOUBAO_SEED_1_6_FLASH = {
+  id: "doubao-seed-1-6-flash-250617"};
+var DEEPSEEK_V3 = {
+  id: "deepseek-v3-1-terminus",
+  displayName: "DeepSeek V3",
+  provider: "DeepSeek"
+};
+var QWEN_MAX = { id: "qwen-max"};
+var QWEN_MAX_LATEST = { id: "qwen-max-latest"};
+var QWEN_PLUS = { id: "qwen-plus"};
+var QWEN_PLUS_LATEST = { id: "qwen-plus-latest"};
+var QWEN_TURBO = { id: "qwen-turbo"};
+var QWEN_TURBO_LATEST = { id: "qwen-turbo-latest"};
+var QWEN3_235B = { id: "qwen3-235b-a22b"};
+var QWEN3_MAX_PREVIEW = {
+  id: "qwen3-max-preview",
+  displayName: "\u901A\u4E49\u5343\u95EE 3 Max",
+  provider: "\u901A\u4E49\u5343\u95EE"
+};
+var GEMINI_2_5_FLASH = { id: "gemini-2.5-flash-preview-05-20"};
+var GEMINI_2_5_PRO = { id: "gemini-2.5-pro-preview-05-06"};
+var GEMINI_2_0_FLASH = { id: "gemini-2.0-flash"};
+var GEMINI_2_0_FLASH_LITE = { id: "gemini-2.0-flash-lite"};
+var GEMINI_3_PRO = {
+  id: "gemini-3-pro-preview",
+  displayName: "Gemini 3 Pro",
+  provider: "Gemini"
+};
+var GEMINI_IMAGE_MODEL = "gemini-2.0-flash";
+var GEMINI_IMAGE_GEN_MODEL = "gemini-3-pro-image-preview";
+var OR_GEMINI_2_5_FLASH = {
+  id: "google/gemini-2.5-flash-preview"};
+var OR_GEMINI_2_5_PRO = {
+  id: "google/gemini-2.5-pro-preview"};
+var OR_GEMINI_2_0_FLASH = {
+  id: "google/gemini-2.0-flash-001"};
+var OR_GEMINI_3_PRO = {
+  id: "google/gemini-3-pro-preview",
+  displayName: "Gemini 3 Pro",
+  isOpenRouter: true,
+  provider: "Gemini"
+};
+var OR_GPT_5_2 = {
+  id: "openai/gpt-5.2",
+  displayName: "GPT-5.2",
+  isOpenRouter: true,
+  provider: "OpenAI"
+};
+var OR_CLAUDE_OPUS_4_5 = {
+  id: "anthropic/claude-opus-4.5",
+  displayName: "Claude Opus 4.5",
+  isOpenRouter: true,
+  provider: "Anthropic"
+};
+var OR_QWEN3_MAX = {
+  id: "qwen/qwen3-max",
+  displayName: "\u901A\u4E49\u5343\u95EE Max",
+  isOpenRouter: true,
+  provider: "\u901A\u4E49\u5343\u95EE"
+};
+var OR_DEEPSEEK_R1 = {
+  id: "deepseek/deepseek-r1"};
+var OR_DEEPSEEK_CHAT_V3 = {
+  id: "deepseek/deepseek-chat-v3-0324"};
+var OR_DEEPSEEK_V3_2 = {
+  id: "deepseek/deepseek-v3.2",
+  displayName: "DeepSeek V3.2",
+  isOpenRouter: true,
+  provider: "DeepSeek"
+};
+var DISPLAY_MODELS = [
+  // 原生模型
+  DOUBAO_SEED_1_6,
+  DEEPSEEK_V3,
+  QWEN3_MAX_PREVIEW,
+  GEMINI_3_PRO,
+  // OpenRouter 模型
+  OR_GPT_5_2,
+  OR_CLAUDE_OPUS_4_5,
+  OR_GEMINI_3_PRO,
+  OR_QWEN3_MAX,
+  OR_DEEPSEEK_V3_2
+];
+var DEFAULT_MODEL = DOUBAO_SEED_1_6.id;
+var PLAN_MODE_PROMPT = "\u5206\u6790\u9700\u6C42\u5E76\u5236\u5B9A\u6267\u884C\u8BA1\u5212\uFF0C\u4EE5 Markdown \u683C\u5F0F\u8F93\u51FA\u6B65\u9AA4\uFF0C\u7B49\u5F85\u7528\u6237\u786E\u8BA4\u540E\u518D\u6267\u884C\u3002";
+var AGENT_MODE_PROMPT = `\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684 AI \u52A9\u624B\u3002\u8BF7\u9075\u5FAA\u4EE5\u4E0B\u89C4\u5219\uFF1A
+- \u8FD4\u56DE\u7684\u5185\u5BB9\u5C3D\u91CF\u4E0D\u8981\u4F7F\u7528\u8868\u60C5\u7B26\u53F7\uFF08emoji\uFF09\uFF0C\u9664\u975E\u7528\u6237\u8981\u6C42\u4F7F\u7528
+- \u4F7F\u7528 Markdown \u683C\u5F0F\u7EC4\u7EC7\u5185\u5BB9
+- \u4EE3\u7801\u5757\u4F7F\u7528\u6B63\u786E\u7684\u8BED\u8A00\u6807\u8BC6`;
+
 // 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 扩展思考
+var MODELS = DISPLAY_MODELS.map((m) => ({
+  modelId: m.id,
+  displayName: m.displayName,
+  group: m.isOpenRouter ? "OpenRouter" : "\u539F\u751F\u6A21\u578B",
+  // 后端决定分组
+  isOpenRouter: m.isOpenRouter,
+  provider: m.provider
+}));
+function getNativeModels() {
+  return MODELS.filter((m) => !m.isOpenRouter);
+}
+function getOpenRouterModels() {
+  return MODELS.filter((m) => m.isOpenRouter);
+}
+function getModelByModelId(modelId) {
+  return MODELS.find((m) => m.modelId === modelId);
+}
+function tool(t) {
+  return { tools: [t] };
+}
+function tools(ts) {
+  return { tools: ts };
+}
+async function resolveTools(items) {
+  const tools2 = [];
+  for (const item of items) {
+    const resolved = await item;
+    if ("tools" in resolved && Array.isArray(resolved.tools)) {
+      tools2.push(...resolved.tools);
+    } else {
+      console.warn("\u5DE5\u5177\u914D\u7F6E\u9879\u5FC5\u987B\u662F ToolPlugin \u5F62\u5F0F:", resolved);
+    }
   }
-];
+  return tools2;
+}
 
-// 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"]
-        }
-      }
+// src/events.ts
+function createThinkingStart() {
+  return {
+    type: "thinking_start",
+    data: { startedAt: Date.now() }
+  };
+}
+function createThinkingDelta(content) {
+  return {
+    type: "thinking_delta",
+    data: { content }
+  };
+}
+function createThinkingEnd(startedAt) {
+  const endedAt = Date.now();
+  return {
+    type: "thinking_end",
+    data: {
+      endedAt,
+      duration: endedAt - startedAt
     }
-  ];
+  };
+}
+function createSearchStart(query) {
+  return {
+    type: "search_start",
+    data: { query, startedAt: Date.now() }
+  };
+}
+function createSearchResult(results, startedAt) {
+  const endedAt = Date.now();
+  return {
+    type: "search_result",
+    data: {
+      results,
+      endedAt,
+      duration: endedAt - startedAt
+    }
+  };
+}
+function createSearchEnd(success, startedAt, error) {
+  const endedAt = Date.now();
+  return {
+    type: "search_end",
+    data: {
+      success,
+      error,
+      endedAt,
+      duration: endedAt - startedAt
+    }
+  };
+}
+function createToolCallStart(id, name, args) {
+  return {
+    type: "tool_call_start",
+    data: { id, name, args, startedAt: Date.now() }
+  };
+}
+function createToolCallResult(id, name, result, success, startedAt, error, sideEffects) {
+  const endedAt = Date.now();
+  return {
+    type: "tool_call_result",
+    data: {
+      id,
+      name,
+      result,
+      success,
+      error,
+      endedAt,
+      duration: endedAt - startedAt,
+      sideEffects
+    }
+  };
+}
+function createTextDelta(content) {
+  return {
+    type: "text_delta",
+    data: { content }
+  };
+}
+function createStreamStart(model, requestId) {
+  return {
+    type: "stream_start",
+    data: {
+      model,
+      requestId,
+      startedAt: Date.now()
+    }
+  };
+}
+function createDone(text, usage, duration) {
+  return {
+    type: "done",
+    data: { text, usage, duration }
+  };
+}
+function createError(details) {
+  return {
+    type: "error",
+    data: details
+  };
+}
+function createApiError(message, options = {}) {
+  return createError({
+    category: "api",
+    message,
+    ...options
+  });
+}
+function createRateLimitError(message, retryAfter, context) {
+  return createError({
+    category: "rate_limit",
+    message,
+    code: "RATE_LIMIT",
+    statusCode: 429,
+    retryable: true,
+    retryAfter,
+    context
+  });
+}
+function createToolError(message, toolName, cause) {
+  return createError({
+    category: "tool",
+    message,
+    code: "TOOL_ERROR",
+    context: toolName,
+    cause,
+    retryable: false
+  });
+}
+function createTimeoutError(message, context) {
+  return createError({
+    category: "timeout",
+    message,
+    code: "TIMEOUT",
+    retryable: true,
+    context
+  });
+}
+function createParseError(message, cause) {
+  return createError({
+    category: "parse",
+    message,
+    code: "PARSE_ERROR",
+    cause,
+    retryable: false
+  });
+}
+function createAbort(reason) {
+  return {
+    type: "abort",
+    data: {
+      reason,
+      abortedAt: Date.now()
+    }
+  };
+}
+function createStepStart(stepNumber, description) {
+  return {
+    type: "step_start",
+    data: { stepNumber, description, startedAt: Date.now() }
+  };
+}
+function createStepEnd(stepNumber, startedAt) {
+  const endedAt = Date.now();
+  return {
+    type: "step_end",
+    data: {
+      stepNumber,
+      endedAt,
+      duration: endedAt - startedAt
+    }
+  };
+}
+function createImage(options) {
+  return {
+    type: "image",
+    data: options
+  };
+}
+function createVideo(path) {
+  return {
+    type: "video",
+    data: { path }
+  };
+}
+function isThinkingEvent(event) {
+  return event.type.startsWith("thinking_");
+}
+function isSearchEvent(event) {
+  return event.type.startsWith("search_");
+}
+function isToolEvent(event) {
+  return event.type.startsWith("tool_");
+}
+function isTextEvent(event) {
+  return event.type === "text_delta";
+}
+function isMediaEvent(event) {
+  return event.type === "image" || event.type === "video";
+}
+function isStatusEvent(event) {
+  return event.type === "stream_start" || event.type === "done" || event.type === "error" || event.type === "abort";
 }
+function isErrorEvent(event) {
+  return event.type === "error";
+}
+function isAbortEvent(event) {
+  return event.type === "abort";
+}
+function isStepEvent(event) {
+  return event.type.startsWith("step_");
+}
+function isRetryableError(event) {
+  if (event.type !== "error") return false;
+  return event.data.retryable === true;
+}
+
+// src/tools.ts
 var DANGEROUS_COMMANDS = [
   "rm -rf /",
   "rm -rf ~",
@@ -147,529 +381,877 @@ function isDangerousCommand(command) {
     (dangerous) => lowerCommand.includes(dangerous.toLowerCase())
   );
 }
-function createDefaultToolExecutor(workingDir = DEFAULT_WORKING_DIR) {
+function createDefaultToolExecutor(defaultCwd = process.cwd()) {
   return {
-    async executeCommand(command, cwd) {
+    async executeCommand(command, cwd, signal) {
+      if (signal?.aborted) {
+        return { success: false, error: "\u64CD\u4F5C\u5DF2\u53D6\u6D88" };
+      }
       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"
+        const { spawn } = await import('child_process');
+        return new Promise((resolve) => {
+          let stdout = "";
+          let stderr = "";
+          let killed = false;
+          const child = spawn("sh", ["-c", command], {
+            cwd: cwd || defaultCwd,
+            env: process.env
+          });
+          const timeout = setTimeout(() => {
+            if (!killed) {
+              killed = true;
+              child.kill("SIGTERM");
+              resolve({ success: false, error: "\u547D\u4EE4\u6267\u884C\u8D85\u65F6\uFF0830\u79D2\uFF09" });
+            }
+          }, 3e4);
+          const abortHandler = () => {
+            if (!killed) {
+              killed = true;
+              child.kill("SIGTERM");
+              clearTimeout(timeout);
+              resolve({ success: false, error: "\u64CD\u4F5C\u5DF2\u53D6\u6D88" });
+            }
+          };
+          signal?.addEventListener("abort", abortHandler);
+          child.stdout?.on("data", (data) => {
+            stdout += data.toString();
+          });
+          child.stderr?.on("data", (data) => {
+            stderr += data.toString();
+          });
+          child.on("close", (code) => {
+            clearTimeout(timeout);
+            signal?.removeEventListener("abort", abortHandler);
+            if (killed) return;
+            const output = stdout.trim();
+            const errOutput = stderr.trim();
+            if (code === 0) {
+              resolve({ success: true, output: output || errOutput || "\u6267\u884C\u6210\u529F" });
+            } else {
+              if (output) {
+                const warning = errOutput ? `
+[\u8B66\u544A: ${errOutput}]` : "";
+                resolve({ success: true, output: output + warning });
+              } else if (errOutput) {
+                resolve({ success: false, error: errOutput });
+              } else {
+                resolve({ success: false, error: `\u547D\u4EE4\u9000\u51FA\u7801: ${code}` });
+              }
+            }
+          });
+          child.on("error", (err) => {
+            clearTimeout(timeout);
+            signal?.removeEventListener("abort", abortHandler);
+            if (!killed) {
+              resolve({ success: false, error: err.message });
+            }
+          });
         });
-        return { success: true, output: (stdout || stderr || "").trim() };
       } catch (error) {
-        return { success: false, error: String(error) };
+        return { success: false, error: error instanceof Error ? error.message : 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"]
+// src/router.ts
+var MODEL_ROUTES = [
+  // === 高优先级：OpenRouter 格式（包含 /）===
+  // 所有包含 / 的模型名都路由到 OpenRouter
+  // 例如：qwen/qwen3-max, anthropic/claude-opus-4.5, openai/gpt-5.2
+  {
+    type: "contains",
+    pattern: "/",
+    provider: "openrouter",
+    priority: 100,
+    description: "OpenRouter \u683C\u5F0F\u6A21\u578B\uFF08vendor/model\uFF09"
+  },
+  // === 中优先级：原生 Provider 前缀匹配 ===
+  {
+    type: "prefix",
+    pattern: "qwen",
+    provider: "qwen",
+    priority: 50,
+    description: "Qwen (DashScope) \u539F\u751F\u6A21\u578B"
+  },
+  {
+    type: "prefix",
+    pattern: "gemini",
+    provider: "gemini",
+    priority: 50,
+    description: "Gemini (Google AI) \u539F\u751F\u6A21\u578B"
+  },
+  // === 低优先级：ARK 火山引擎模型 ===
+  {
+    type: "prefix",
+    pattern: "doubao",
+    provider: "ark",
+    priority: 30,
+    description: "\u8C46\u5305\u6A21\u578B\uFF08\u706B\u5C71\u5F15\u64CE\uFF09"
   },
-  "deepseek-v3-1-terminus": {
-    supportsTools: true,
-    supportsWebSearch: true,
-    supportsThinking: true,
-    supportedThinkingModes: ["enabled", "disabled"]
+  {
+    type: "prefix",
+    pattern: "deepseek",
+    provider: "ark",
+    priority: 30,
+    description: "DeepSeek \u6A21\u578B\uFF08\u706B\u5C71\u5F15\u64CE\uFF09"
   }
-};
-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
-    };
-  });
+];
+var DEFAULT_PROVIDER = "ark";
+var sortedRulesCache = null;
+function getSortedRules() {
+  if (!sortedRulesCache) {
+    sortedRulesCache = [...MODEL_ROUTES].sort((a, b) => b.priority - a.priority);
+  }
+  return sortedRulesCache;
 }
-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}`
-      });
+function matchRule(model, rule) {
+  const lowerPattern = rule.pattern.toLowerCase();
+  switch (rule.type) {
+    case "exact":
+      return model === lowerPattern;
+    case "prefix":
+      return model.startsWith(lowerPattern);
+    case "contains":
+      return model.includes(lowerPattern);
+    case "regex":
+      return new RegExp(rule.pattern, "i").test(model);
+    default:
+      return false;
+  }
+}
+function routeModelToProvider(model) {
+  return routeModelWithDetails(model).provider;
+}
+function routeModelWithDetails(model) {
+  const lowerModel = model.toLowerCase();
+  const sortedRules = getSortedRules();
+  for (const rule of sortedRules) {
+    if (matchRule(lowerModel, rule)) {
+      return {
+        provider: rule.provider,
+        matchedRule: rule,
+        isDefault: false
+      };
     }
   }
-  input.push({
-    role: "user",
-    content: [{ type: "input_text", text: message }]
-  });
-  return input;
+  return {
+    provider: DEFAULT_PROVIDER,
+    isDefault: true
+  };
 }
-var ArkProvider = class {
-  name = "ark";
-  supportedModels = ARK_MODELS;
-  apiKey;
-  apiUrl;
-  enableCaching;
+function getRouteRules() {
+  return MODEL_ROUTES;
+}
+function getDefaultProvider() {
+  return DEFAULT_PROVIDER;
+}
+function isModelForProvider(model, provider) {
+  return routeModelToProvider(model) === provider;
+}
+
+// src/providers/orchestrator.ts
+var DEFAULT_MAX_ITERATIONS = 10;
+var ChatOrchestrator = class {
+  config;
   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;
+    this.config = {
+      maxIterations: DEFAULT_MAX_ITERATIONS,
+      ...config
+    };
   }
   /**
-   * 聊天入口 - 统一使用 Responses API
+   * 执行聊天
+   * 
+   * @param adapter Provider 适配器
+   * @param message 用户消息
+   * @param context Orchestrator 上下文
+   * @param options 选项
    */
-  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);
+  async *chat(adapter, message, context, options) {
+    const startedAt = Date.now();
+    const maxIterations = this.config.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    const messages = this.buildMessages(context, message);
     let iterations = 0;
     let finalText = "";
-    let thinkingComplete = !showThinking;
-    let searchComplete = !enableWebSearch;
+    let thinkingText = "";
+    let thinkingStartedAt = 0;
+    let thinkingComplete = !options.enableThinking;
     let searchResults = [];
-    let hasExecutedTools = false;
-    const pendingFunctionCalls = /* @__PURE__ */ new Map();
-    while (iterations < MAX_ITERATIONS) {
+    let searchStartedAt = 0;
+    let searchStarted = false;
+    if (options.enableThinking) {
+      thinkingStartedAt = Date.now();
+      yield createThinkingStart();
+    }
+    while (iterations < maxIterations) {
       if (context.signal.aborted) {
-        yield { type: "error", data: "\u8BF7\u6C42\u5DF2\u53D6\u6D88" };
+        yield createAbort("\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),
+        const pendingToolCalls = [];
+        let hasToolCalls = false;
+        const stream = adapter.streamOnce(messages, context.tools, {
+          model: options.model,
+          enableThinking: options.enableThinking && iterations === 1,
+          // 只在第一轮启用思考
+          enableSearch: options.enableSearch && iterations === 1,
           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": {
+        for await (const chunk of stream) {
+          switch (chunk.type) {
+            case "text":
+              if (chunk.text) {
+                if (!thinkingComplete) {
                   thinkingComplete = true;
-                  yield {
-                    type: "thinking",
-                    data: { content: "", isComplete: true }
-                  };
-                  break;
+                  yield createThinkingEnd(thinkingStartedAt);
                 }
-                // 响应完成
-                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")) {
-                  }
+                finalText += chunk.text;
+                yield createTextDelta(chunk.text);
+              }
+              break;
+            case "thinking":
+              if (chunk.thinking) {
+                thinkingText += chunk.thinking;
+                yield createThinkingDelta(chunk.thinking);
+              }
+              break;
+            case "thinking_done":
+              if (!thinkingComplete) {
+                thinkingComplete = true;
+                yield createThinkingEnd(thinkingStartedAt);
+              }
+              break;
+            case "tool_call":
+              if (chunk.toolCall) {
+                pendingToolCalls.push(chunk.toolCall);
+                hasToolCalls = true;
+              }
+              break;
+            case "search_result":
+              if (chunk.searchResults) {
+                if (!searchStarted) {
+                  searchStarted = true;
+                  searchStartedAt = Date.now();
+                  yield createSearchStart(message);
                 }
+                searchResults = chunk.searchResults;
+                yield createSearchResult(searchResults, searchStartedAt);
               }
-            } catch {
-            }
+              break;
+            case "done":
+              if (chunk.finishReason === "tool_calls") {
+                hasToolCalls = true;
+              }
+              break;
+            case "error":
+              yield createApiError(chunk.error ?? "\u672A\u77E5\u9519\u8BEF");
+              return;
           }
         }
-        if (needsFunctionExecution && pendingFunctionCalls.size > 0) {
-          for (const [callId, call] of pendingFunctionCalls) {
-            if (!call.name) continue;
+        if (!thinkingComplete) {
+          thinkingComplete = true;
+          yield createThinkingEnd(thinkingStartedAt);
+        }
+        if (hasToolCalls && pendingToolCalls.length > 0) {
+          const assistantMessage = {
+            role: "assistant",
+            content: finalText,
+            toolCalls: pendingToolCalls
+          };
+          messages.push(assistantMessage);
+          for (const toolCall of pendingToolCalls) {
+            const toolStartedAt = Date.now();
             let args;
             try {
-              args = JSON.parse(call.arguments || "{}");
+              args = JSON.parse(toolCall.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"
+              messages.push({
+                role: "tool",
+                content: "\u53C2\u6570\u89E3\u6790\u9519\u8BEF",
+                toolCallId: toolCall.id
               });
               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
+            const autoRunConfig = this.config.getAutoRunConfig ? await this.config.getAutoRunConfig() : options.autoRunConfig || this.config.autoRunConfig;
+            console.log("[Orchestrator] \u68C0\u67E5\u5DE5\u5177\u6279\u51C6:", {
+              toolName: toolCall.name,
+              autoRunConfigMode: autoRunConfig?.mode,
+              hasCallback: !!this.config.onToolApprovalRequest
             });
-            hasExecutedTools = true;
+            if (autoRunConfig?.mode === "manual" && this.config.onToolApprovalRequest) {
+              console.log("[Orchestrator] \u53D1\u9001\u5DE5\u5177\u6279\u51C6\u8BF7\u6C42:", toolCall.name);
+              const approvalRequest = {
+                type: "tool_approval_request",
+                data: {
+                  id: toolCall.id,
+                  name: toolCall.name,
+                  args,
+                  requestedAt: Date.now()
+                }
+              };
+              yield approvalRequest;
+              const approved = await this.config.onToolApprovalRequest({
+                id: toolCall.id,
+                name: toolCall.name,
+                args
+              });
+              if (!approved) {
+                const result2 = JSON.stringify({ skipped: true, message: "\u7528\u6237\u8DF3\u8FC7\u4E86\u6B64\u5DE5\u5177" });
+                yield createToolCallResult(toolCall.id, toolCall.name, result2, false, toolStartedAt);
+                messages.push({
+                  role: "tool",
+                  content: result2,
+                  toolCallId: toolCall.id,
+                  toolName: toolCall.name
+                });
+                continue;
+              }
+            }
+            yield createToolCallStart(toolCall.id, toolCall.name, args);
+            let result;
+            let dynamicSideEffects;
+            let success = true;
+            try {
+              const executeResult = await this.config.executeTool(toolCall.name, args, context.signal);
+              if (typeof executeResult === "string") {
+                result = executeResult;
+              } else {
+                result = executeResult.result;
+                dynamicSideEffects = executeResult.sideEffects;
+              }
+            } catch (error) {
+              success = false;
+              const errorMessage = error instanceof Error ? error.message : String(error);
+              result = `\u9519\u8BEF: ${errorMessage}`;
+            }
+            const tool2 = this.config.tools?.get(toolCall.name);
+            const sideEffects = dynamicSideEffects ?? tool2?.sideEffects;
+            yield createToolCallResult(toolCall.id, toolCall.name, result, success, toolStartedAt, void 0, sideEffects);
+            messages.push({
+              role: "tool",
+              content: result,
+              toolCallId: toolCall.id,
+              toolName: toolCall.name
+              // Gemini 需要工具名称
+            });
+            if (context.signal.aborted) {
+              yield createAbort("\u8BF7\u6C42\u5DF2\u53D6\u6D88");
+              return;
+            }
           }
-          pendingFunctionCalls.clear();
+          finalText = "";
           continue;
         }
         break;
       } catch (error) {
         if (context.signal.aborted) {
-          yield { type: "error", data: "\u8BF7\u6C42\u5DF2\u53D6\u6D88" };
+          yield createAbort("\u8BF7\u6C42\u5DF2\u53D6\u6D88");
         } else {
-          yield { type: "error", data: String(error) };
+          yield createApiError(error instanceof Error ? error.message : String(error));
         }
-        break;
+        return;
       }
     }
-    if (!thinkingComplete) {
-      yield { type: "thinking", data: { content: "", isComplete: true } };
+    if (searchStarted) {
+      yield createSearchEnd(true, searchStartedAt);
+    }
+    const duration = Date.now() - startedAt;
+    yield createDone(finalText, void 0, duration);
+  }
+  /**
+   * 构建标准化消息列表
+   */
+  buildMessages(context, message) {
+    const messages = [];
+    if (context.systemPrompt) {
+      messages.push({
+        role: "system",
+        content: context.systemPrompt
+      });
     }
-    if (searchStarted && !searchComplete) {
-      yield { type: "search_result", data: { results: searchResults, isComplete: true } };
+    for (const msg of context.history) {
+      const standardMsg = {
+        role: msg.role,
+        content: msg.content
+      };
+      if (msg.tool_calls) {
+        standardMsg.toolCalls = msg.tool_calls.map((tc) => ({
+          id: tc.id,
+          name: tc.function.name,
+          arguments: tc.function.arguments
+        }));
+      }
+      messages.push(standardMsg);
     }
-    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 };
+    messages.push({
+      role: "user",
+      content: message,
+      images: context.images
+    });
+    return messages;
   }
 };
+function createOrchestrator(config) {
+  return new ChatOrchestrator(config);
+}
 
-// src/providers/qwen.ts
-var QWEN_MODELS = [
-  "qwen3-max-preview",
-  "qwen-plus"
+// src/providers/adapters/ark.ts
+var ARK_MODELS = [
+  DOUBAO_SEED_1_8.id,
+  DOUBAO_SEED_1_6.id,
+  DOUBAO_SEED_1_6_LATEST.id,
+  DOUBAO_SEED_1_6_FLASH.id,
+  "doubao-1-5-pro-32k-250115",
+  "doubao-1-5-pro-256k-250115",
+  "doubao-1-5-lite-32k-250115"
 ];
-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 ArkAdapter = class {
+  name = "ark";
+  supportedModels = ARK_MODELS;
+  apiKey;
+  apiUrl;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.apiUrl = config.apiUrl ?? DEFAULT_ARK_URL;
+  }
+  supportsModel(model) {
+    return this.supportedModels.some((m) => model.includes(m) || m.includes(model));
+  }
+  /**
+   * 单次流式调用
+   */
+  async *streamOnce(messages, tools2, options) {
+    const input = this.convertMessages(messages);
+    const requestBody = {
+      model: options.model,
+      stream: true,
+      max_output_tokens: 32768,
+      input
+    };
+    const apiTools = [];
+    if (options.enableSearch) {
+      apiTools.push({ type: "web_search", max_keyword: 5, limit: 20 });
+    }
+    if (tools2.length > 0) {
+      for (const t of tools2) {
+        apiTools.push({
+          type: "function",
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters
+        });
+      }
+    }
+    if (apiTools.length > 0) {
+      requestBody.tools = apiTools;
+    }
+    if (options.enableThinking) {
+      requestBody.thinking = { 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: options.signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      yield { type: "error", error: `ARK API \u9519\u8BEF: ${response.status} - ${errorText}` };
+      return;
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      yield { type: "error", error: "\u65E0\u6CD5\u83B7\u53D6\u54CD\u5E94\u6D41" };
+      return;
+    }
+    yield* this.parseStream(reader);
+  }
+  /**
+   * 转换标准消息为 ARK Responses API 格式
+   */
+  convertMessages(messages) {
+    const input = [];
+    for (const msg of messages) {
+      switch (msg.role) {
+        case "system":
+          input.push({ role: "system", content: msg.content });
+          break;
+        case "user": {
+          const content = [{ type: "input_text", text: msg.content }];
+          if (msg.images?.length) {
+            for (const img of msg.images) {
+              content.push({
+                type: "input_image",
+                image_url: img.startsWith("data:") ? img : `data:image/jpeg;base64,${img}`
+              });
+            }
+          }
+          input.push({ role: "user", content });
+          break;
+        }
+        case "assistant":
+          if (msg.toolCalls?.length) {
+            for (const tc of msg.toolCalls) {
+              input.push({
+                type: "function_call",
+                call_id: tc.id,
+                name: tc.name,
+                arguments: tc.arguments
+              });
+            }
+          } else {
+            input.push({
+              role: "developer",
+              content: `[\u4E0A\u4E00\u8F6EAI\u56DE\u590D]: ${msg.content}`
+            });
+          }
+          break;
+        case "tool":
+          input.push({
+            type: "function_call_output",
+            call_id: msg.toolCallId,
+            output: msg.content
+          });
+          break;
+      }
+    }
+    return input;
+  }
+  /**
+   * 解析 ARK 流式响应
+   */
+  async *parseStream(reader) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const pendingToolCalls = /* @__PURE__ */ new Map();
+    let currentFunctionCallId = null;
+    const searchResults = [];
+    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:")) continue;
+        const data = line.slice(5).trim();
+        if (data === "[DONE]") {
+          if (pendingToolCalls.size > 0) {
+            for (const tc of pendingToolCalls.values()) {
+              yield { type: "tool_call", toolCall: tc };
+            }
+            yield { type: "done", finishReason: "tool_calls" };
+          } else {
+            yield { type: "done", finishReason: "stop" };
+          }
+          return;
+        }
+        try {
+          const event = JSON.parse(data);
+          switch (event.type) {
+            case "response.output_item.added": {
+              const item = event.item;
+              if (item?.type === "function_call") {
+                const callId = item.call_id;
+                if (!callId) {
+                  console.warn("[ARK] function_call \u7F3A\u5C11 call_id");
+                  break;
+                }
+                currentFunctionCallId = callId;
+                pendingToolCalls.set(callId, {
+                  id: callId,
+                  name: item.name || "",
+                  arguments: item.arguments || ""
+                });
+              }
+              break;
+            }
+            case "response.function_call_arguments.delta": {
+              if (currentFunctionCallId) {
+                const call = pendingToolCalls.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.call_id) {
+                const callId = item.call_id;
+                const existing = pendingToolCalls.get(callId);
+                pendingToolCalls.set(callId, {
+                  id: callId,
+                  name: item.name || existing?.name || "",
+                  arguments: item.arguments || existing?.arguments || "{}"
+                });
+              }
+              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 || ""
+                  });
+                  yield { type: "search_result", searchResults: [...searchResults] };
+                }
+              }
+              break;
+            }
+            case "response.output_text.delta":
+              if (event.delta) {
+                yield { type: "text", text: event.delta };
+              }
+              break;
+            case "response.reasoning_summary_text.delta":
+              if (event.delta) {
+                yield { type: "thinking", thinking: event.delta };
+              }
+              break;
+            case "response.reasoning_summary_text.done":
+              yield { type: "thinking_done" };
+              break;
+          }
+        } catch {
+        }
+      }
+    }
+    if (pendingToolCalls.size > 0) {
+      for (const tc of pendingToolCalls.values()) {
+        yield { type: "tool_call", toolCall: tc };
+      }
+      yield { type: "done", finishReason: "tool_calls" };
+    } else {
+      yield { type: "done", finishReason: "stop" };
+    }
   }
 };
-var DEFAULT_CAPABILITIES2 = {
-  supportsTools: true,
-  supportsWebSearch: true,
-  supportsThinking: true,
-  supportedThinkingModes: ["enabled", "disabled"]
-};
-var QwenProvider = class {
-  name = "qwen";
-  supportedModels = QWEN_MODELS;
+function createArkAdapter(config) {
+  return new ArkAdapter(config);
+}
+
+// src/providers/adapters/openrouter.ts
+var OPENROUTER_MODELS = [
+  OR_GEMINI_2_5_FLASH.id,
+  OR_GEMINI_2_5_PRO.id,
+  OR_GEMINI_2_0_FLASH.id,
+  "anthropic/claude-sonnet-4",
+  "anthropic/claude-3.5-sonnet",
+  "openai/gpt-4o",
+  "openai/gpt-4o-mini",
+  OR_DEEPSEEK_R1.id,
+  OR_DEEPSEEK_CHAT_V3.id
+];
+var OpenRouterAdapter = class {
+  name = "openrouter";
+  supportedModels = OPENROUTER_MODELS;
   apiKey;
   apiUrl;
   constructor(config) {
     this.apiKey = config.apiKey;
-    this.apiUrl = config.apiUrl || DEFAULT_QWEN_NATIVE_URL;
+    this.apiUrl = config.apiUrl ?? DEFAULT_OPENROUTER_URL;
   }
   supportsModel(model) {
-    return QWEN_MODELS.includes(model) || model.startsWith("qwen");
+    return this.supportedModels.some((m) => model.includes(m) || m.includes(model));
   }
-  getModelCapabilities(model) {
-    return MODEL_CAPABILITIES2[model] || DEFAULT_CAPABILITIES2;
+  /**
+   * 单次流式调用
+   */
+  async *streamOnce(messages, tools2, options) {
+    const apiMessages = this.convertMessages(messages);
+    const requestBody = {
+      model: options.model,
+      messages: apiMessages,
+      stream: true,
+      max_tokens: 32768
+    };
+    if (tools2.length > 0) {
+      requestBody.tools = tools2.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters
+        }
+      }));
+    }
+    if (options.model.includes("gemini") && options.enableThinking) {
+      requestBody.reasoning = { effort: "high" };
+    }
+    if (options.model.includes("claude") && options.enableThinking) {
+      requestBody.reasoning = { effort: "high", exclude: false };
+    }
+    if (options.enableSearch) {
+      const isSmallContext = options.model.includes("deepseek") || options.model.includes("qwen");
+      const maxResults = isSmallContext ? 2 : 3;
+      requestBody.plugins = [{ id: "web", max_results: maxResults }];
+    }
+    const response = await fetch(`${this.apiUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        "HTTP-Referer": "https://ai-chat.local",
+        "X-Title": "AI Chat"
+      },
+      body: JSON.stringify(requestBody),
+      signal: options.signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      yield { type: "error", error: `OpenRouter API \u9519\u8BEF: ${response.status} - ${errorText}` };
+      return;
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      yield { type: "error", error: "\u65E0\u6CD5\u83B7\u53D6\u54CD\u5E94\u6D41" };
+      return;
+    }
+    yield* this.parseStream(reader);
   }
-  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;
+  /**
+   * 转换标准消息为 OpenAI 格式
+   */
+  convertMessages(messages) {
+    const apiMessages = [];
+    for (const msg of messages) {
+      switch (msg.role) {
+        case "system":
+          apiMessages.push({ role: "system", content: msg.content });
+          break;
+        case "user": {
+          if (msg.images?.length) {
+            const content = [{ type: "text", text: msg.content }];
+            for (const img of msg.images) {
+              content.push({
+                type: "image_url",
+                image_url: { url: img.startsWith("data:") ? img : `data:image/jpeg;base64,${img}` }
+              });
+            }
+            apiMessages.push({ role: "user", content });
+          } else {
+            apiMessages.push({ role: "user", content: msg.content });
+          }
+          break;
+        }
+        case "assistant":
+          if (msg.toolCalls?.length) {
+            apiMessages.push({
+              role: "assistant",
+              content: msg.content || null,
+              tool_calls: msg.toolCalls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: {
+                  name: tc.name,
+                  arguments: tc.arguments
+                }
+              }))
+            });
+          } else {
+            apiMessages.push({ role: "assistant", content: msg.content });
+          }
+          break;
+        case "tool":
+          apiMessages.push({
+            role: "tool",
+            tool_call_id: msg.toolCallId,
+            content: msg.content
+          });
+          break;
       }
-      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
+    }
+    return apiMessages;
+  }
+  /**
+   * 解析 OpenAI 兼容流式响应
+   */
+  async *parseStream(reader) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const toolCallsMap = /* @__PURE__ */ new Map();
+    let toolCallCounter = 0;
+    let finishReason = null;
+    const searchResults = [];
+    let hasThinking = false;
+    let thinkingDone = false;
+    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:")) continue;
+        const data = line.slice(5).trim();
+        if (data === "[DONE]") {
+          if (searchResults.length > 0) {
+            yield { type: "search_result", searchResults: [...searchResults] };
+          }
+          if (toolCallsMap.size > 0) {
+            for (const tc of toolCallsMap.values()) {
+              if (tc.name) {
+                yield { type: "tool_call", toolCall: tc };
               }
-            };
+            }
+            yield { type: "done", finishReason: "tool_calls" };
+          } else {
+            yield { type: "done", finishReason: "stop" };
+          }
+          return;
+        }
+        try {
+          const json = JSON.parse(data);
+          const choice = json.choices?.[0];
+          const annotations = json.annotations;
+          if (annotations?.length) {
+            for (const annotation of annotations) {
+              if (annotation.type === "url_citation" && annotation.url_citation?.url) {
+                const exists = searchResults.some((r) => r.url === annotation.url_citation.url);
+                if (!exists) {
+                  searchResults.push({
+                    url: annotation.url_citation.url,
+                    title: annotation.url_citation.title || "",
+                    snippet: annotation.url_citation.content || ""
+                  });
+                  yield { type: "search_result", searchResults: [...searchResults] };
+                }
+              }
+            }
           }
           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 } };
+          const delta = choice.delta || {};
+          finishReason = choice.finish_reason;
+          if (delta.reasoning) {
+            hasThinking = true;
+            yield { type: "thinking", thinking: delta.reasoning };
           }
-          if (msg.content) {
-            if (!thinkingComplete) {
-              thinkingComplete = true;
-              yield { type: "thinking", data: { content: "", isComplete: true } };
+          if (delta.content) {
+            if (hasThinking && !thinkingDone) {
+              thinkingDone = true;
+              yield { type: "thinking_done" };
             }
-            finalText += msg.content;
-            yield { type: "text_delta", data: msg.content };
+            yield { type: "text", text: delta.content };
           }
-          if (msg.tool_calls?.length) {
-            for (const tc of msg.tool_calls) {
-              const index = tc.index ?? 0;
+          if (delta.tool_calls?.length) {
+            for (const tc of delta.tool_calls) {
+              const index = tc.index;
               const existing = toolCallsMap.get(index);
               if (existing) {
                 if (tc.function?.arguments) {
@@ -683,126 +1265,99 @@ var QwenProvider = class {
                 }
               } else {
                 toolCallsMap.set(index, {
-                  id: tc.id || `call_${Date.now()}_${index}`,
+                  id: tc.id || `call_${Date.now()}_${toolCallCounter++}`,
                   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
+          if (finishReason === "tool_calls") {
+            for (const tc of toolCallsMap.values()) {
+              if (tc.name) {
+                yield { type: "tool_call", toolCall: tc };
               }
-            }))
-          });
-          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;
+            yield { type: "done", finishReason: "tool_calls" };
+            return;
           }
-          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) };
+        } catch {
         }
-        break;
       }
     }
-    if (!searchComplete) {
-      yield { type: "search_result", data: { results: [], isComplete: true } };
+    if (searchResults.length > 0) {
+      yield { type: "search_result", searchResults: [...searchResults] };
     }
-    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 };
+    if (toolCallsMap.size > 0) {
+      for (const tc of toolCallsMap.values()) {
+        if (tc.name) {
+          yield { type: "tool_call", toolCall: tc };
+        }
+      }
+      yield { type: "done", finishReason: "tool_calls" };
+    } else {
+      yield { type: "done", finishReason: "stop" };
+    }
+  }
+};
+function createOpenRouterAdapter(config) {
+  return new OpenRouterAdapter(config);
+}
+
+// src/providers/adapters/qwen.ts
+var QWEN_MODELS = [
+  QWEN_MAX.id,
+  QWEN_MAX_LATEST.id,
+  QWEN_PLUS.id,
+  QWEN_PLUS_LATEST.id,
+  QWEN_TURBO.id,
+  QWEN_TURBO_LATEST.id,
+  QWEN3_235B.id
+];
+var QwenAdapter = class {
+  name = "qwen";
+  supportedModels = QWEN_MODELS;
+  apiKey;
+  apiUrl;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.apiUrl = config.apiUrl ?? DEFAULT_QWEN_URL;
   }
-  /** 调用 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;
-    });
+  supportsModel(model) {
+    return this.supportedModels.some((m) => model.includes(m) || m.includes(model));
+  }
+  /**
+   * 单次流式调用
+   */
+  async *streamOnce(messages, tools2, options) {
+    const apiMessages = this.convertMessages(messages);
     const requestBody = {
-      model,
-      input: { messages: formattedMessages },
+      model: options.model,
+      input: { messages: apiMessages },
       parameters: {
         result_format: "message",
         incremental_output: true,
-        max_tokens: 32768
+        enable_search: options.enableSearch,
+        // 深度思考支持
+        ...options.enableThinking && {
+          enable_thinking: true,
+          thinking_budget: 38400
+        }
       }
     };
-    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 (tools2.length > 0) {
+      requestBody.parameters = {
+        ...requestBody.parameters,
+        tools: tools2.map((t) => ({
+          type: "function",
+          function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters
+          }
+        }))
       };
     }
-    if (tools.length > 0) {
-      params.tools = tools;
-    }
     const response = await fetch(`${this.apiUrl}/services/aigc/text-generation/generation`, {
       method: "POST",
       headers: {
@@ -811,18 +1366,85 @@ var QwenProvider = class {
         "X-DashScope-SSE": "enable"
       },
       body: JSON.stringify(requestBody),
-      signal
+      signal: options.signal
     });
     if (!response.ok) {
       const errorText = await response.text();
-      throw new Error(`DashScope API \u9519\u8BEF: ${response.status} - ${errorText}`);
+      yield { type: "error", error: `Qwen API \u9519\u8BEF: ${response.status} - ${errorText}` };
+      return;
     }
     const reader = response.body?.getReader();
     if (!reader) {
-      throw new Error("\u65E0\u6CD5\u83B7\u53D6\u54CD\u5E94\u6D41");
+      yield { type: "error", error: "\u65E0\u6CD5\u83B7\u53D6\u54CD\u5E94\u6D41" };
+      return;
+    }
+    yield* this.parseStream(reader);
+  }
+  /**
+   * 转换标准消息为 Qwen 格式
+   */
+  convertMessages(messages) {
+    const apiMessages = [];
+    for (const msg of messages) {
+      switch (msg.role) {
+        case "system":
+          apiMessages.push({ role: "system", content: msg.content });
+          break;
+        case "user": {
+          if (msg.images?.length) {
+            const content = [{ type: "text", text: msg.content }];
+            for (const img of msg.images) {
+              content.push({
+                type: "image_url",
+                image_url: { url: img.startsWith("data:") ? img : `data:image/jpeg;base64,${img}` }
+              });
+            }
+            apiMessages.push({ role: "user", content });
+          } else {
+            apiMessages.push({ role: "user", content: msg.content });
+          }
+          break;
+        }
+        case "assistant":
+          if (msg.toolCalls?.length) {
+            apiMessages.push({
+              role: "assistant",
+              content: msg.content || "",
+              tool_calls: msg.toolCalls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: {
+                  name: tc.name,
+                  arguments: tc.arguments
+                }
+              }))
+            });
+          } else {
+            apiMessages.push({ role: "assistant", content: msg.content });
+          }
+          break;
+        case "tool":
+          apiMessages.push({
+            role: "tool",
+            tool_call_id: msg.toolCallId,
+            content: msg.content
+          });
+          break;
+      }
     }
+    return apiMessages;
+  }
+  /**
+   * 解析 Qwen 流式响应
+   */
+  async *parseStream(reader) {
     const decoder = new TextDecoder();
     let buffer = "";
+    const toolCallsMap = /* @__PURE__ */ new Map();
+    let toolCallCounter = 0;
+    const searchResults = [];
+    let hasThinking = false;
+    let thinkingDone = false;
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
@@ -830,422 +1452,533 @@ var QwenProvider = class {
       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 {
+        if (!line.startsWith("data:")) continue;
+        const data = line.slice(5).trim();
+        if (!data || data === "[DONE]") continue;
+        try {
+          const json = JSON.parse(data);
+          const output = json.output;
+          if (!output) continue;
+          const choice = output.choices?.[0];
+          const message = choice?.message || {};
+          const finishReason = choice?.finish_reason;
+          if (message.reasoning_content) {
+            hasThinking = true;
+            yield { type: "thinking", thinking: message.reasoning_content };
+          }
+          if (message.content) {
+            if (!thinkingDone && hasThinking) {
+              thinkingDone = true;
+              yield { type: "thinking_done" };
+            }
+            yield { type: "text", text: message.content };
+          }
+          const searchInfo = json.output?.search_info;
+          if (searchInfo?.search_results?.length) {
+            for (const result of searchInfo.search_results) {
+              const exists = searchResults.some((r) => r.url === result.url);
+              if (!exists) {
+                searchResults.push({
+                  title: result.title || "",
+                  url: result.url || "",
+                  snippet: result.snippet || ""
+                });
+              }
+            }
+            yield { type: "search_result", searchResults: [...searchResults] };
+          }
+          if (message.tool_calls?.length) {
+            for (const tc of message.tool_calls) {
+              const index = toolCallsMap.size;
+              const existing = toolCallsMap.get(index);
+              if (existing) {
+                if (tc.function?.arguments) {
+                  existing.arguments += tc.function.arguments;
+                }
+              } else {
+                toolCallsMap.set(index, {
+                  id: tc.id || `call_${Date.now()}_${toolCallCounter++}`,
+                  name: tc.function.name,
+                  arguments: tc.function.arguments
+                });
+              }
+            }
+          }
+          if (finishReason === "stop" || finishReason === "length" || finishReason === "tool_calls") {
+            if (toolCallsMap.size > 0) {
+              for (const tc of toolCallsMap.values()) {
+                yield { type: "tool_call", toolCall: tc };
+              }
+              yield { type: "done", finishReason: "tool_calls" };
+            } else {
+              yield { type: "done", finishReason: "stop" };
             }
+            return;
           }
+        } catch {
         }
       }
     }
+    if (toolCallsMap.size > 0) {
+      for (const tc of toolCallsMap.values()) {
+        yield { type: "tool_call", toolCall: tc };
+      }
+      yield { type: "done", finishReason: "tool_calls" };
+    } else {
+      yield { type: "done", finishReason: "stop" };
+    }
   }
 };
+function createQwenAdapter(config) {
+  return new QwenAdapter(config);
+}
 
-// src/providers/gemini.ts
+// src/providers/adapters/gemini.ts
 var GEMINI_MODELS = [
-  "gemini-3-pro-preview"
+  GEMINI_2_5_FLASH.id,
+  GEMINI_2_5_PRO.id,
+  GEMINI_2_0_FLASH.id,
+  GEMINI_2_0_FLASH_LITE.id,
+  GEMINI_3_PRO.id
 ];
-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 {
+var GeminiAdapter = class {
   name = "gemini";
   supportedModels = GEMINI_MODELS;
-  geminiClient = null;
+  client = null;
   apiKey;
   constructor(config) {
     this.apiKey = config.apiKey;
   }
-  /** 懒加载 Gemini 客户端 */
+  /** 懒加载客户端 */
   async getClient() {
-    if (!this.geminiClient) {
+    if (!this.client) {
       const { GoogleGenAI: GoogleGenAI2 } = await import('@google/genai');
-      this.geminiClient = new GoogleGenAI2({ apiKey: this.apiKey });
+      this.client = new GoogleGenAI2({ apiKey: this.apiKey });
     }
-    return this.geminiClient;
+    return this.client;
   }
   supportsModel(model) {
-    return GEMINI_MODELS.includes(model) || model.startsWith("gemini-");
+    return this.supportedModels.some((m) => model.includes(m) || m.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
-            }
-          };
+  /**
+   * 单次流式调用
+   */
+  async *streamOnce(messages, tools2, options) {
+    const client = await this.getClient();
+    const geminiMessages = this.convertMessages(messages);
+    const generateConfig = {};
+    const toolsConfig = [];
+    if (tools2.length > 0) {
+      toolsConfig.push({
+        functionDeclarations: tools2.map((t) => ({
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters
+        }))
+      });
+    }
+    if (options.enableSearch) {
+      toolsConfig.push({ googleSearch: {} });
+    }
+    if (toolsConfig.length > 0) {
+      generateConfig.tools = toolsConfig;
+    }
+    if (options.enableThinking) {
+      generateConfig.thinkingConfig = {
+        thinkingLevel: "high",
+        includeThoughts: true
+      };
+    }
+    try {
+      const streamResponse = await client.models.generateContentStream({
+        model: options.model,
+        contents: geminiMessages,
+        config: generateConfig
+      });
+      const pendingToolCalls = [];
+      let toolCallCounter = 0;
+      let hasThinking = false;
+      let thinkingDone = false;
+      for await (const chunk of streamResponse) {
+        if (options.signal.aborted) {
+          yield { type: "error", error: "\u8BF7\u6C42\u5DF2\u53D6\u6D88" };
+          return;
         }
+        const candidate = chunk.candidates?.[0];
+        if (!candidate) continue;
         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 } };
+          if (part.thought && part.text) {
+            hasThinking = true;
+            yield { type: "thinking", thinking: part.text };
             continue;
           }
-          if (part.text && !extendedPart.thought) {
-            if (!thinkingComplete) {
-              thinkingComplete = true;
-              yield { type: "thinking", data: { content: "", isComplete: true } };
+          if (part.text && !part.thought) {
+            if (hasThinking && !thinkingDone) {
+              thinkingDone = true;
+              yield { type: "thinking_done" };
             }
-            finalText += part.text;
-            yield { type: "text_delta", data: part.text };
+            yield { type: "text", text: 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;
+            pendingToolCalls.push({
+              id: `call_${Date.now()}_${toolCallCounter++}`,
+              name: part.functionCall.name,
+              arguments: JSON.stringify(part.functionCall.args || {})
+            });
+          }
+        }
+      }
+      if (pendingToolCalls.length > 0) {
+        for (const tc of pendingToolCalls) {
+          yield { type: "tool_call", toolCall: tc };
+        }
+        yield { type: "done", finishReason: "tool_calls" };
+      } else {
+        yield { type: "done", finishReason: "stop" };
+      }
+    } catch (error) {
+      const errorStr = String(error);
+      if (errorStr.includes("User location is not supported") || errorStr.includes("FAILED_PRECONDITION")) {
+        yield {
+          type: "error",
+          error: "Gemini API \u4E0D\u652F\u6301\u5F53\u524D\u5730\u533A\uFF08\u4E2D\u56FD\u5927\u9646\u65E0\u6CD5\u8BBF\u95EE\uFF09\u3002\u8BF7\u4F7F\u7528\u5176\u4ED6\u6A21\u578B\u3002"
+        };
+      } else {
+        yield { type: "error", error: errorStr };
+      }
+    }
+  }
+  /**
+   * 转换标准消息为 Gemini 格式
+   */
+  convertMessages(messages) {
+    const geminiMessages = [];
+    for (const msg of messages) {
+      switch (msg.role) {
+        case "system":
+          geminiMessages.push(
+            { role: "user", parts: [{ text: msg.content }] },
+            { role: "model", parts: [{ text: "OK" }] }
+          );
+          break;
+        case "user": {
+          const parts = [{ text: msg.content }];
+          if (msg.images?.length) {
+            for (const img of msg.images) {
+              const base64 = img.startsWith("data:") ? img.split(",")[1] : img;
+              parts.push({
+                inlineData: {
+                  mimeType: "image/jpeg",
+                  data: base64
+                }
+              });
+            }
+          }
+          geminiMessages.push({ role: "user", parts });
+          break;
+        }
+        case "assistant":
+          if (msg.toolCalls?.length) {
+            const parts = [];
+            if (msg.content) {
+              parts.push({ text: msg.content });
+            }
+            for (const tc of msg.toolCalls) {
+              parts.push({
+                functionCall: {
+                  name: tc.name,
+                  args: JSON.parse(tc.arguments || "{}")
+                }
+              });
             }
+            geminiMessages.push({ role: "model", parts });
+          } else {
             geminiMessages.push({
               role: "model",
-              parts: [modelPart]
-            });
-            geminiMessages.push({
-              role: "user",
-              parts: [{ functionResponse: { name, response: { result } } }]
+              parts: [{ text: msg.content }]
             });
           }
-        }
-        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;
+        case "tool":
+          geminiMessages.push({
+            role: "user",
+            parts: [{
+              functionResponse: {
+                name: msg.toolName || "unknown_tool",
+                response: { result: msg.content }
+              }
+            }]
+          });
+          break;
       }
     }
-    if (!thinkingComplete) {
-      yield { type: "thinking", data: { content: "", isComplete: true } };
-    }
-    if (!searchComplete) {
-      yield { type: "search_result", data: { results: [], isComplete: true } };
+    return geminiMessages;
+  }
+};
+function createGeminiAdapter(config) {
+  return new GeminiAdapter(config);
+}
+
+// src/agent.ts
+var HybridAgent = class {
+  config;
+  adapters = /* @__PURE__ */ new Map();
+  orchestrator;
+  geminiClient;
+  toolExecutor;
+  abortController = null;
+  /** 已注册的工具 */
+  tools = /* @__PURE__ */ new Map();
+  /** 工具配置（用于异步初始化） */
+  toolConfig;
+  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,
+      cwd: config.cwd || process.cwd(),
+      planPrompt: config.planPrompt || PLAN_MODE_PROMPT
+    };
+    this.geminiClient = new genai.GoogleGenAI({ apiKey: this.config.geminiApiKey });
+    this.toolExecutor = toolExecutor || createDefaultToolExecutor(this.config.cwd);
+    this.toolConfig = config.tools;
+    this.tools = /* @__PURE__ */ new Map();
+    this.initializeAdapters();
+    this.orchestrator = new ChatOrchestrator({
+      maxIterations: 10,
+      executeTool: this.executeTool.bind(this),
+      tools: this.tools,
+      // 传入工具列表，用于获取 sideEffects
+      // autoRunConfig 在每次 chat 调用时通过 options 传递
+      onToolApprovalRequest: config.onToolApprovalRequest,
+      // 传递工具批准回调
+      getAutoRunConfig: config.getAutoRunConfig
+      // 传递动态获取配置回调
+    });
+  }
+  /** 异步初始化工具（在第一次 chat 前调用） */
+  async asyncInit() {
+    if (this.toolConfig && this.tools.size === 0) {
+      const resolvedTools = await resolveTools(this.toolConfig);
+      for (const tool2 of resolvedTools) {
+        this.tools.set(tool2.name, tool2);
+      }
     }
-    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 }]
-    }));
+  /** 初始化所有 Adapter */
+  initializeAdapters() {
+    if (this.config.arkApiKey) {
+      this.adapters.set("ark", new ArkAdapter({
+        apiKey: this.config.arkApiKey,
+        apiUrl: this.config.arkApiUrl
+      }));
+    }
+    if (this.config.qwenApiKey) {
+      this.adapters.set("qwen", new QwenAdapter({
+        apiKey: this.config.qwenApiKey,
+        apiUrl: this.config.qwenApiUrl
+      }));
+    }
+    if (this.config.geminiApiKey) {
+      this.adapters.set("gemini", new GeminiAdapter({
+        apiKey: this.config.geminiApiKey
+      }));
+    }
+    if (this.config.openrouterApiKey) {
+      this.adapters.set("openrouter", new OpenRouterAdapter({
+        apiKey: this.config.openrouterApiKey,
+        apiUrl: this.config.openrouterApiUrl
+      }));
+    }
   }
-  /** 转换工具定义为 Gemini functionDeclarations 格式 */
-  convertToGeminiFunctions(tools) {
-    return tools.map((tool) => {
-      const t = tool;
-      return {
-        name: t.function.name,
-        description: t.function.description,
-        parameters: t.function.parameters
-      };
-    });
+  /** 
+   * 判断模型提供商
+   */
+  getModelProvider(model) {
+    return routeModelToProvider(model);
   }
-};
-
-// 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"]
+  /** 获取 Adapter */
+  getAdapter(model) {
+    const providerName = this.getModelProvider(model);
+    return this.adapters.get(providerName);
   }
-};
-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;
+  /**
+   * 调试：获取模型路由信息
+   */
+  getModelRouteInfo(model) {
+    const result = routeModelWithDetails(model);
+    return {
+      ...result,
+      available: this.adapters.has(result.provider)
+    };
   }
-  supportsModel(model) {
-    return OPENROUTER_MODELS.includes(model) || model.includes("/");
+  /** 构建系统提示词 */
+  buildSystemPrompt(options) {
+    if (options.mode === "plan") {
+      return this.config.planPrompt;
+    }
+    return AGENT_MODE_PROMPT;
   }
-  getModelCapabilities(model) {
-    return MODEL_CAPABILITIES4[model] || DEFAULT_CAPABILITIES4;
+  /** 获取默认深度思考模式 */
+  getDefaultThinkingMode() {
+    return "disabled";
   }
-  /** 检查模型是否支持 Extended Thinking */
-  supportsThinking(model) {
-    return model.includes("claude-opus-4.5") || model === "anthropic/claude-opus-4.5";
+  /** 创建工具执行上下文 */
+  createToolContext(signal) {
+    return {
+      cwd: this.config.cwd,
+      geminiClient: this.geminiClient,
+      executeCommand: (command, cwd) => this.toolExecutor.executeCommand(command, cwd || this.config.cwd, signal),
+      signal
+    };
   }
-  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;
-      }
+  /** 执行工具 */
+  async executeTool(name, args, signal) {
+    const tool2 = this.tools.get(name);
+    if (!tool2) {
+      return `\u672A\u77E5\u5DE5\u5177: ${name}`;
     }
-    if (!thinkingComplete) {
-      yield { type: "thinking", data: { content: "", isComplete: true } };
+    return await tool2.execute(args, this.createToolContext(signal));
+  }
+  /** 获取工具定义列表 */
+  getToolDefinitions() {
+    return Array.from(this.tools.values()).map((tool2) => ({
+      name: tool2.name,
+      description: tool2.description,
+      parameters: tool2.parameters
+    }));
+  }
+  /**
+   * 聊天入口
+   * 
+   * 使用 ChatOrchestrator 统一处理所有 Provider 的工具调用循环
+   */
+  async *chat(message, options = {}, images) {
+    await this.asyncInit();
+    this.abortController = new AbortController();
+    const signal = this.abortController.signal;
+    const model = options.model || DEFAULT_MODEL;
+    const adapter = this.getAdapter(model);
+    if (!adapter) {
+      const providerName = this.getModelProvider(model);
+      yield createApiError(`\u7F3A\u5C11 ${providerName} Provider \u7684 API Key`, { code: "MISSING_API_KEY" });
+      return;
     }
-    if (!searchComplete) {
-      yield { type: "search_result", data: { results: [], isComplete: true } };
+    const thinkingMode = options.thinkingMode ?? this.getDefaultThinkingMode();
+    const systemPrompt = this.buildSystemPrompt(options);
+    const tools2 = options.mode === "ask" ? [] : this.getToolDefinitions();
+    const history = options.history || [];
+    const context = {
+      systemPrompt,
+      history,
+      tools: tools2,
+      signal,
+      images
+    };
+    try {
+      yield* this.orchestrator.chat(adapter, message, context, {
+        model,
+        enableThinking: thinkingMode === "enabled",
+        enableSearch: options.enableWebSearch,
+        autoRunConfig: options.autoRunConfig
+      });
+    } finally {
+      this.abortController = null;
     }
-    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
-        // 包含推理过程
-      };
+  /** 中断当前请求 */
+  abort() {
+    if (this.abortController) {
+      this.abortController.abort();
     }
-    if (tools.length > 0) {
-      requestBody.tools = tools;
+  }
+  /** 设置当前工作目录 */
+  setCwd(dir) {
+    this.config.cwd = dir;
+  }
+  /** 获取当前配置 */
+  getConfig() {
+    return { ...this.config };
+  }
+  /** 获取所有支持的模型 */
+  getSupportedModels() {
+    return MODELS;
+  }
+};
+
+// src/builtin-tools/get-cwd.ts
+function getCwdTool() {
+  return tool({
+    name: "get_cwd",
+    description: "\u83B7\u53D6\u7528\u6237\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u7684\u7EDD\u5BF9\u8DEF\u5F84\u3002\u5F53\u4F60\u9700\u8981\u77E5\u9053\u7528\u6237\u5728\u54EA\u4E2A\u76EE\u5F55\u4E0B\u5DE5\u4F5C\u65F6\u4F7F\u7528\u3002",
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    execute: async (_args, context) => {
+      return JSON.stringify({ cwd: context.cwd });
     }
-    if (enableWebSearch) {
-      requestBody.plugins = [
-        {
-          id: "web",
-          max_results: 5
-        }
-      ];
+  });
+}
+
+// src/builtin-tools/get-platform.ts
+function getPlatformTool() {
+  return tool({
+    name: "get_platform",
+    description: "\u83B7\u53D6\u64CD\u4F5C\u7CFB\u7EDF\u4FE1\u606F\uFF08macOS/Windows/Linux\uFF09\u3002\u5F53\u4F60\u9700\u8981\u786E\u5B9A\u4F7F\u7528\u54EA\u79CD\u547D\u4EE4\u8BED\u6CD5\u65F6\u8C03\u7528\uFF08\u5982 ls vs dir\uFF09\u3002",
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    execute: async () => {
+      const os = await import('os');
+      const platform = os.default.platform();
+      const platformName = platform === "darwin" ? "macOS" : platform === "win32" ? "Windows" : "Linux";
+      const shell = platform === "win32" ? "powershell" : "bash/zsh";
+      const pathSeparator = platform === "win32" ? "\\" : "/";
+      return JSON.stringify({
+        platform,
+        platformName,
+        shell,
+        pathSeparator
+      });
     }
-    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"
+  });
+}
+
+// src/builtin-tools/execute-command.ts
+function executeCommandTool() {
+  return tool({
+    name: "execute_command",
+    description: "\u6267\u884C shell \u547D\u4EE4\u3002\u6267\u884C\u524D\u5EFA\u8BAE\u5148\u7528 get_cwd \u83B7\u53D6\u5F53\u524D\u76EE\u5F55\u3001get_platform \u83B7\u53D6\u7CFB\u7EDF\u7C7B\u578B\uFF0C\u4EE5\u786E\u4FDD\u4F7F\u7528\u6B63\u786E\u7684\u8DEF\u5F84\u548C\u547D\u4EE4\u8BED\u6CD5\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "\u8981\u6267\u884C\u7684\u547D\u4EE4" },
+        cwd: { type: "string", description: "\u6267\u884C\u547D\u4EE4\u7684\u76EE\u5F55\uFF08\u4E0D\u4F20\u5219\u4F7F\u7528\u7528\u6237\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09" }
       },
-      body: JSON.stringify(requestBody),
-      signal
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`OpenRouter API \u9519\u8BEF: ${response.status} - ${errorText}`);
+      required: ["command"]
+    },
+    execute: async (args, context) => {
+      const cwd = args.cwd || context.cwd;
+      const result = await context.executeCommand(args.command, cwd);
+      if (result.success) {
+        return result.output || "\u6267\u884C\u6210\u529F";
+      }
+      if (result.error === "\u64CD\u4F5C\u5DF2\u53D6\u6D88") {
+        return JSON.stringify({ success: false, error: "\u64CD\u4F5C\u5DF2\u53D6\u6D88", cancelled: true });
+      }
+      return `\u9519\u8BEF: ${result.error}`;
     }
-    return response.json();
-  }
-};
+  });
+}
 
 // src/gemini.ts
 function getMimeType(ext) {
@@ -1267,8 +2000,11 @@ function getVideoMimeType(ext) {
   };
   return types[ext] || "video/mp4";
 }
-async function analyzeImage(geminiClient, imagePath, question) {
+async function analyzeImage(geminiClient, imagePath, question, signal) {
   try {
+    if (signal?.aborted) {
+      return JSON.stringify({ success: false, error: "\u64CD\u4F5C\u5DF2\u53D6\u6D88", cancelled: true });
+    }
     const fs = await import('fs/promises');
     const path = await import('path');
     const imageData = await fs.readFile(imagePath);
@@ -1283,43 +2019,53 @@ async function analyzeImage(geminiClient, imagePath, question) {
           { text: question || "\u8BF7\u8BE6\u7EC6\u63CF\u8FF0\u8FD9\u5F20\u56FE\u7247\u7684\u5185\u5BB9" },
           { inlineData: { mimeType, data: base64 } }
         ]
-      }]
+      }],
+      config: { abortSignal: signal }
     });
     return response.text || "\u65E0\u6CD5\u5206\u6790\u56FE\u7247";
   } catch (error) {
+    if (signal?.aborted) return JSON.stringify({ success: false, error: "\u64CD\u4F5C\u5DF2\u53D6\u6D88", cancelled: true });
     return `\u56FE\u7247\u5206\u6790\u5931\u8D25: ${error}`;
   }
 }
-async function generateImage(geminiClient, workingDir, prompt, outputPath) {
+async function generateImage(geminiClient, cwd, prompt, outputPath, signal) {
   try {
+    if (signal?.aborted) {
+      return JSON.stringify({ success: false, error: "\u64CD\u4F5C\u5DF2\u53D6\u6D88" });
+    }
     const response = await geminiClient.models.generateContent({
       model: GEMINI_IMAGE_GEN_MODEL,
-      contents: [{ role: "user", parts: [{ text: prompt }] }]
+      contents: [{ role: "user", parts: [{ text: prompt }] }],
+      config: { abortSignal: signal }
     });
     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}`;
-        }
+        const fs = await import('fs/promises');
+        const savePath = outputPath || `${cwd}/generated_${Date.now()}${ext}`;
+        await fs.writeFile(savePath, imageData);
+        return JSON.stringify({
+          success: true,
+          path: savePath,
+          format: mimeType
+        });
       }
     }
-    return "\u56FE\u7247\u751F\u6210\u5931\u8D25";
+    return JSON.stringify({ success: false, error: "\u56FE\u7247\u751F\u6210\u5931\u8D25" });
   } catch (error) {
-    return `\u56FE\u7247\u751F\u6210\u5931\u8D25: ${error}`;
+    if (signal?.aborted) {
+      return JSON.stringify({ success: false, error: "\u64CD\u4F5C\u5DF2\u53D6\u6D88", cancelled: true });
+    }
+    return JSON.stringify({ success: false, error: `\u56FE\u7247\u751F\u6210\u5931\u8D25: ${error}` });
   }
 }
-async function analyzeVideo(geminiClient, videoPath, question) {
+async function analyzeVideo(geminiClient, videoPath, question, signal) {
   try {
+    if (signal?.aborted) {
+      return JSON.stringify({ success: false, error: "\u64CD\u4F5C\u5DF2\u53D6\u6D88", cancelled: true });
+    }
     const fs = await import('fs/promises');
     const path = await import('path');
     const videoData = await fs.readFile(videoPath);
@@ -1334,230 +2080,790 @@ async function analyzeVideo(geminiClient, videoPath, question) {
           { text: question || "\u8BF7\u8BE6\u7EC6\u63CF\u8FF0\u8FD9\u4E2A\u89C6\u9891\u7684\u5185\u5BB9" },
           { inlineData: { mimeType, data: base64 } }
         ]
-      }]
+      }],
+      config: { abortSignal: signal }
     });
     return response.text || "\u65E0\u6CD5\u5206\u6790\u89C6\u9891";
   } catch (error) {
+    if (signal?.aborted) return JSON.stringify({ success: false, error: "\u64CD\u4F5C\u5DF2\u53D6\u6D88", cancelled: true });
     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 genai.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
-      }));
+// src/builtin-tools/analyze-image.ts
+function analyzeImageTool() {
+  return tool({
+    name: "analyze_image",
+    description: "\u5206\u6790\u56FE\u7247\u5185\u5BB9\uFF08\u8BC6\u522B\u7269\u4F53\u3001\u573A\u666F\u3001\u6587\u5B57\u7B49\uFF09",
+    parameters: {
+      type: "object",
+      properties: {
+        imagePath: { type: "string", description: "\u56FE\u7247\u6587\u4EF6\u8DEF\u5F84" },
+        question: { type: "string", description: "\u5173\u4E8E\u56FE\u7247\u7684\u95EE\u9898\uFF08\u53EF\u9009\uFF09" }
+      },
+      required: ["imagePath"]
+    },
+    execute: async (args, context) => {
+      if (!context.geminiClient) {
+        return "\u9519\u8BEF: \u672A\u914D\u7F6E Gemini API Key\uFF0C\u65E0\u6CD5\u4F7F\u7528\u56FE\u7247\u5206\u6790\u529F\u80FD";
+      }
+      return await analyzeImage(
+        context.geminiClient,
+        args.imagePath,
+        args.question,
+        context.signal
+      );
     }
-    if (this.config.geminiApiKey) {
-      this.providers.set("gemini", new GeminiProvider({
-        apiKey: this.config.geminiApiKey
-      }));
+  });
+}
+
+// src/builtin-tools/generate-image.ts
+function generateImageTool() {
+  return tool({
+    name: "generate_image",
+    description: "\u6839\u636E\u6587\u5B57\u63CF\u8FF0\u751F\u6210\u56FE\u7247\u5E76\u4FDD\u5B58\u5230\u672C\u5730\u3002\u8FD4\u56DE\u4FDD\u5B58\u8DEF\u5F84\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        prompt: { type: "string", description: "\u56FE\u7247\u63CF\u8FF0\uFF0C\u4F7F\u7528\u8BE6\u7EC6\u7684\u82F1\u6587\u63CF\u8FF0\u6548\u679C\u66F4\u597D" },
+        outputPath: { type: "string", description: "\u4FDD\u5B58\u8DEF\u5F84\uFF08\u53EF\u9009\uFF09" }
+      },
+      required: ["prompt"]
+    },
+    // 图片生成完成后通知用户
+    sideEffects: [{ type: "notification", success: true, message: "\u{1F3A8} \u56FE\u7247\u751F\u6210\u5B8C\u6210" }],
+    execute: async (args, context) => {
+      if (!context.geminiClient) {
+        return "\u9519\u8BEF: \u672A\u914D\u7F6E Gemini API Key\uFF0C\u65E0\u6CD5\u4F7F\u7528\u56FE\u7247\u751F\u6210\u529F\u80FD";
+      }
+      return await generateImage(
+        context.geminiClient,
+        context.cwd,
+        args.prompt,
+        args.outputPath,
+        context.signal
+      );
     }
-    if (this.config.openrouterApiKey) {
-      this.providers.set("openrouter", new OpenRouterProvider({
-        apiKey: this.config.openrouterApiKey,
-        apiUrl: this.config.openrouterApiUrl
-      }));
+  });
+}
+
+// src/builtin-tools/analyze-video.ts
+function analyzeVideoTool() {
+  return tool({
+    name: "analyze_video",
+    description: "\u5206\u6790\u89C6\u9891\u5185\u5BB9\uFF08\u8BC6\u522B\u573A\u666F\u3001\u52A8\u4F5C\u3001\u7269\u4F53\u7B49\uFF09",
+    parameters: {
+      type: "object",
+      properties: {
+        videoPath: { type: "string", description: "\u89C6\u9891\u6587\u4EF6\u8DEF\u5F84" },
+        question: { type: "string", description: "\u5173\u4E8E\u89C6\u9891\u7684\u95EE\u9898\uFF08\u53EF\u9009\uFF09" }
+      },
+      required: ["videoPath"]
+    },
+    execute: async (args, context) => {
+      if (!context.geminiClient) {
+        return "\u9519\u8BEF: \u672A\u914D\u7F6E Gemini API Key\uFF0C\u65E0\u6CD5\u4F7F\u7528\u89C6\u9891\u5206\u6790\u529F\u80FD";
+      }
+      return await analyzeVideo(
+        context.geminiClient,
+        args.videoPath,
+        args.question,
+        context.signal
+      );
     }
+  });
+}
+
+// src/builtin-tools/weather/city-adcodes.ts
+var CITY_ADCODE_MAP = {
+  // 直辖市
+  "\u5317\u4EAC": "110000",
+  "\u5929\u6D25": "120000",
+  "\u4E0A\u6D77": "310000",
+  "\u91CD\u5E86": "500000",
+  // 河北省
+  "\u77F3\u5BB6\u5E84": "130100",
+  "\u5510\u5C71": "130200",
+  "\u79E6\u7687\u5C9B": "130300",
+  "\u90AF\u90F8": "130400",
+  "\u90A2\u53F0": "130500",
+  "\u4FDD\u5B9A": "130600",
+  "\u5F20\u5BB6\u53E3": "130700",
+  "\u627F\u5FB7": "130800",
+  "\u6CA7\u5DDE": "130900",
+  "\u5ECA\u574A": "131000",
+  "\u8861\u6C34": "131100",
+  // 山西省
+  "\u592A\u539F": "140100",
+  "\u5927\u540C": "140200",
+  "\u9633\u6CC9": "140300",
+  "\u957F\u6CBB": "140400",
+  "\u664B\u57CE": "140500",
+  "\u6714\u5DDE": "140600",
+  "\u664B\u4E2D": "140700",
+  "\u8FD0\u57CE": "140800",
+  "\u5FFB\u5DDE": "140900",
+  "\u4E34\u6C7E": "141000",
+  "\u5415\u6881": "141100",
+  // 内蒙古自治区
+  "\u547C\u548C\u6D69\u7279": "150100",
+  "\u5305\u5934": "150200",
+  "\u4E4C\u6D77": "150300",
+  "\u8D64\u5CF0": "150400",
+  "\u901A\u8FBD": "150500",
+  "\u9102\u5C14\u591A\u65AF": "150600",
+  "\u547C\u4F26\u8D1D\u5C14": "150700",
+  "\u5DF4\u5F66\u6DD6\u5C14": "150800",
+  "\u4E4C\u5170\u5BDF\u5E03": "150900",
+  "\u5174\u5B89\u76DF": "152200",
+  "\u9521\u6797\u90ED\u52D2\u76DF": "152500",
+  "\u963F\u62C9\u5584\u76DF": "152900",
+  // 辽宁省
+  "\u6C88\u9633": "210100",
+  "\u5927\u8FDE": "210200",
+  "\u978D\u5C71": "210300",
+  "\u629A\u987A": "210400",
+  "\u672C\u6EAA": "210500",
+  "\u4E39\u4E1C": "210600",
+  "\u9526\u5DDE": "210700",
+  "\u8425\u53E3": "210800",
+  "\u961C\u65B0": "210900",
+  "\u8FBD\u9633": "211000",
+  "\u76D8\u9526": "211100",
+  "\u94C1\u5CAD": "211200",
+  "\u671D\u9633": "211300",
+  "\u846B\u82A6\u5C9B": "211400",
+  // 吉林省
+  "\u957F\u6625": "220100",
+  "\u5409\u6797": "220200",
+  "\u56DB\u5E73": "220300",
+  "\u8FBD\u6E90": "220400",
+  "\u901A\u5316": "220500",
+  "\u767D\u5C71": "220600",
+  "\u677E\u539F": "220700",
+  "\u767D\u57CE": "220800",
+  "\u5EF6\u8FB9\u671D\u9C9C\u65CF\u81EA\u6CBB\u5DDE": "222400",
+  // 黑龙江省
+  "\u54C8\u5C14\u6EE8": "230100",
+  "\u9F50\u9F50\u54C8\u5C14": "230200",
+  "\u9E21\u897F": "230300",
+  "\u9E64\u5C97": "230400",
+  "\u53CC\u9E2D\u5C71": "230500",
+  "\u5927\u5E86": "230600",
+  "\u4F0A\u6625": "230700",
+  "\u4F73\u6728\u65AF": "230800",
+  "\u4E03\u53F0\u6CB3": "230900",
+  "\u7261\u4E39\u6C5F": "231000",
+  "\u9ED1\u6CB3": "231100",
+  "\u7EE5\u5316": "231200",
+  "\u5927\u5174\u5B89\u5CAD\u5730\u533A": "232700",
+  // 江苏省
+  "\u5357\u4EAC": "320100",
+  "\u65E0\u9521": "320200",
+  "\u5F90\u5DDE": "320300",
+  "\u5E38\u5DDE": "320400",
+  "\u82CF\u5DDE": "320500",
+  "\u5357\u901A": "320600",
+  "\u8FDE\u4E91\u6E2F": "320700",
+  "\u6DEE\u5B89": "320800",
+  "\u76D0\u57CE": "320900",
+  "\u626C\u5DDE": "321000",
+  "\u9547\u6C5F": "321100",
+  "\u6CF0\u5DDE": "321200",
+  "\u5BBF\u8FC1": "321300",
+  // 浙江省
+  "\u676D\u5DDE": "330100",
+  "\u5B81\u6CE2": "330200",
+  "\u6E29\u5DDE": "330300",
+  "\u5609\u5174": "330400",
+  "\u6E56\u5DDE": "330500",
+  "\u7ECD\u5174": "330600",
+  "\u91D1\u534E": "330700",
+  "\u8862\u5DDE": "330800",
+  "\u821F\u5C71": "330900",
+  "\u53F0\u5DDE": "331000",
+  "\u4E3D\u6C34": "331100",
+  // 安徽省
+  "\u5408\u80A5": "340100",
+  "\u829C\u6E56": "340200",
+  "\u868C\u57E0": "340300",
+  "\u6DEE\u5357": "340400",
+  "\u9A6C\u978D\u5C71": "340500",
+  "\u6DEE\u5317": "340600",
+  "\u94DC\u9675": "340700",
+  "\u5B89\u5E86": "340800",
+  "\u9EC4\u5C71": "341000",
+  "\u6EC1\u5DDE": "341100",
+  "\u961C\u9633": "341200",
+  "\u5BBF\u5DDE": "341300",
+  "\u516D\u5B89": "341500",
+  "\u4EB3\u5DDE": "341600",
+  "\u6C60\u5DDE": "341700",
+  "\u5BA3\u57CE": "341800",
+  // 福建省
+  "\u798F\u5DDE": "350100",
+  "\u53A6\u95E8": "350200",
+  "\u8386\u7530": "350300",
+  "\u4E09\u660E": "350400",
+  "\u6CC9\u5DDE": "350500",
+  "\u6F33\u5DDE": "350600",
+  "\u5357\u5E73": "350700",
+  "\u9F99\u5CA9": "350800",
+  "\u5B81\u5FB7": "350900",
+  // 江西省
+  "\u5357\u660C": "360100",
+  "\u666F\u5FB7\u9547": "360200",
+  "\u840D\u4E61": "360300",
+  "\u4E5D\u6C5F": "360400",
+  "\u65B0\u4F59": "360500",
+  "\u9E70\u6F6D": "360600",
+  "\u8D63\u5DDE": "360700",
+  "\u5409\u5B89": "360800",
+  "\u5B9C\u6625": "360900",
+  "\u629A\u5DDE": "361000",
+  "\u4E0A\u9976": "361100",
+  // 山东省
+  "\u6D4E\u5357": "370100",
+  "\u9752\u5C9B": "370200",
+  "\u6DC4\u535A": "370300",
+  "\u67A3\u5E84": "370400",
+  "\u4E1C\u8425": "370500",
+  "\u70DF\u53F0": "370600",
+  "\u6F4D\u574A": "370700",
+  "\u6D4E\u5B81": "370800",
+  "\u6CF0\u5B89": "370900",
+  "\u5A01\u6D77": "371000",
+  "\u65E5\u7167": "371100",
+  "\u4E34\u6C82": "371300",
+  "\u5FB7\u5DDE": "371400",
+  "\u804A\u57CE": "371500",
+  "\u6EE8\u5DDE": "371600",
+  "\u83CF\u6CFD": "371700",
+  // 河南省
+  "\u90D1\u5DDE": "410100",
+  "\u5F00\u5C01": "410200",
+  "\u6D1B\u9633": "410300",
+  "\u5E73\u9876\u5C71": "410400",
+  "\u5B89\u9633": "410500",
+  "\u9E64\u58C1": "410600",
+  "\u65B0\u4E61": "410700",
+  "\u7126\u4F5C": "410800",
+  "\u6FEE\u9633": "410900",
+  "\u8BB8\u660C": "411000",
+  "\u6F2F\u6CB3": "411100",
+  "\u4E09\u95E8\u5CE1": "411200",
+  "\u5357\u9633": "411300",
+  "\u5546\u4E18": "411400",
+  "\u4FE1\u9633": "411500",
+  "\u5468\u53E3": "411600",
+  "\u9A7B\u9A6C\u5E97": "411700",
+  // 湖北省
+  "\u6B66\u6C49": "420100",
+  "\u9EC4\u77F3": "420200",
+  "\u5341\u5830": "420300",
+  "\u5B9C\u660C": "420500",
+  "\u8944\u9633": "420600",
+  "\u9102\u5DDE": "420700",
+  "\u8346\u95E8": "420800",
+  "\u5B5D\u611F": "420900",
+  "\u8346\u5DDE": "421000",
+  "\u9EC4\u5188": "421100",
+  "\u54B8\u5B81": "421200",
+  "\u968F\u5DDE": "421300",
+  "\u6069\u65BD\u571F\u5BB6\u65CF\u82D7\u65CF\u81EA\u6CBB\u5DDE": "422800",
+  // 湖南省
+  "\u957F\u6C99": "430100",
+  "\u682A\u6D32": "430200",
+  "\u6E58\u6F6D": "430300",
+  "\u8861\u9633": "430400",
+  "\u90B5\u9633": "430500",
+  "\u5CB3\u9633": "430600",
+  "\u5E38\u5FB7": "430700",
+  "\u5F20\u5BB6\u754C": "430800",
+  "\u76CA\u9633": "430900",
+  "\u90F4\u5DDE": "431000",
+  "\u6C38\u5DDE": "431100",
+  "\u6000\u5316": "431200",
+  "\u5A04\u5E95": "431300",
+  "\u6E58\u897F\u571F\u5BB6\u65CF\u82D7\u65CF\u81EA\u6CBB\u5DDE": "433100",
+  // 广东省
+  "\u5E7F\u5DDE": "440100",
+  "\u97F6\u5173": "440200",
+  "\u6DF1\u5733": "440300",
+  "\u73E0\u6D77": "440400",
+  "\u6C55\u5934": "440500",
+  "\u4F5B\u5C71": "440600",
+  "\u6C5F\u95E8": "440700",
+  "\u6E5B\u6C5F": "440800",
+  "\u8302\u540D": "440900",
+  "\u8087\u5E86": "441200",
+  "\u60E0\u5DDE": "441300",
+  "\u6885\u5DDE": "441400",
+  "\u6C55\u5C3E": "441500",
+  "\u6CB3\u6E90": "441600",
+  "\u9633\u6C5F": "441700",
+  "\u6E05\u8FDC": "441800",
+  "\u4E1C\u839E": "441900",
+  "\u4E2D\u5C71": "442000",
+  "\u6F6E\u5DDE": "445100",
+  "\u63ED\u9633": "445200",
+  "\u4E91\u6D6E": "445300",
+  // 广西壮族自治区
+  "\u5357\u5B81": "450100",
+  "\u67F3\u5DDE": "450200",
+  "\u6842\u6797": "450300",
+  "\u68A7\u5DDE": "450400",
+  "\u5317\u6D77": "450500",
+  "\u9632\u57CE\u6E2F": "450600",
+  "\u94A6\u5DDE": "450700",
+  "\u8D35\u6E2F": "450800",
+  "\u7389\u6797": "450900",
+  "\u767E\u8272": "451000",
+  "\u8D3A\u5DDE": "451100",
+  "\u6CB3\u6C60": "451200",
+  "\u6765\u5BBE": "451300",
+  "\u5D07\u5DE6": "451400",
+  // 海南省
+  "\u6D77\u53E3": "460100",
+  "\u4E09\u4E9A": "460200",
+  "\u4E09\u6C99": "460300",
+  "\u510B\u5DDE": "460400",
+  // 四川省
+  "\u6210\u90FD": "510100",
+  "\u81EA\u8D21": "510300",
+  "\u6500\u679D\u82B1": "510400",
+  "\u6CF8\u5DDE": "510500",
+  "\u5FB7\u9633": "510600",
+  "\u7EF5\u9633": "510700",
+  "\u5E7F\u5143": "510800",
+  "\u9042\u5B81": "510900",
+  "\u5185\u6C5F": "511000",
+  "\u4E50\u5C71": "511100",
+  "\u5357\u5145": "511300",
+  "\u7709\u5C71": "511400",
+  "\u5B9C\u5BBE": "511500",
+  "\u5E7F\u5B89": "511600",
+  "\u8FBE\u5DDE": "511700",
+  "\u96C5\u5B89": "511800",
+  "\u5DF4\u4E2D": "511900",
+  "\u8D44\u9633": "512000",
+  "\u963F\u575D\u85CF\u65CF\u7F8C\u65CF\u81EA\u6CBB\u5DDE": "513200",
+  "\u7518\u5B5C\u85CF\u65CF\u81EA\u6CBB\u5DDE": "513300",
+  "\u51C9\u5C71\u5F5D\u65CF\u81EA\u6CBB\u5DDE": "513400",
+  // 贵州省
+  "\u8D35\u9633": "520100",
+  "\u516D\u76D8\u6C34": "520200",
+  "\u9075\u4E49": "520300",
+  "\u5B89\u987A": "520400",
+  "\u6BD5\u8282": "520500",
+  "\u94DC\u4EC1": "520600",
+  "\u9ED4\u897F\u5357\u5E03\u4F9D\u65CF\u82D7\u65CF\u81EA\u6CBB\u5DDE": "522300",
+  "\u9ED4\u4E1C\u5357\u82D7\u65CF\u4F97\u65CF\u81EA\u6CBB\u5DDE": "522600",
+  "\u9ED4\u5357\u5E03\u4F9D\u65CF\u82D7\u65CF\u81EA\u6CBB\u5DDE": "522700",
+  // 云南省
+  "\u6606\u660E": "530100",
+  "\u66F2\u9756": "530300",
+  "\u7389\u6EAA": "530400",
+  "\u4FDD\u5C71": "530500",
+  "\u662D\u901A": "530600",
+  "\u4E3D\u6C5F": "530700",
+  "\u666E\u6D31": "530800",
+  "\u4E34\u6CA7": "530900",
+  "\u695A\u96C4\u5F5D\u65CF\u81EA\u6CBB\u5DDE": "532300",
+  "\u7EA2\u6CB3\u54C8\u5C3C\u65CF\u5F5D\u65CF\u81EA\u6CBB\u5DDE": "532500",
+  "\u6587\u5C71\u58EE\u65CF\u82D7\u65CF\u81EA\u6CBB\u5DDE": "532600",
+  "\u897F\u53CC\u7248\u7EB3\u50A3\u65CF\u81EA\u6CBB\u5DDE": "532800",
+  "\u5927\u7406\u767D\u65CF\u81EA\u6CBB\u5DDE": "532900",
+  "\u5FB7\u5B8F\u50A3\u65CF\u666F\u9887\u65CF\u81EA\u6CBB\u5DDE": "533100",
+  "\u6012\u6C5F\u5088\u50F3\u65CF\u81EA\u6CBB\u5DDE": "533300",
+  "\u8FEA\u5E86\u85CF\u65CF\u81EA\u6CBB\u5DDE": "533400",
+  // 西藏自治区
+  "\u62C9\u8428": "540100",
+  "\u65E5\u5580\u5219": "540200",
+  "\u660C\u90FD": "540300",
+  "\u6797\u829D": "540400",
+  "\u5C71\u5357": "540500",
+  "\u90A3\u66F2": "540600",
+  "\u963F\u91CC\u5730\u533A": "542500",
+  // 陕西省
+  "\u897F\u5B89": "610100",
+  "\u94DC\u5DDD": "610200",
+  "\u5B9D\u9E21": "610300",
+  "\u54B8\u9633": "610400",
+  "\u6E2D\u5357": "610500",
+  "\u5EF6\u5B89": "610600",
+  "\u6C49\u4E2D": "610700",
+  "\u6986\u6797": "610800",
+  "\u5B89\u5EB7": "610900",
+  "\u5546\u6D1B": "611000",
+  // 甘肃省
+  "\u5170\u5DDE": "620100",
+  "\u5609\u5CEA\u5173": "620200",
+  "\u91D1\u660C": "620300",
+  "\u767D\u94F6": "620400",
+  "\u5929\u6C34": "620500",
+  "\u6B66\u5A01": "620600",
+  "\u5F20\u6396": "620700",
+  "\u5E73\u51C9": "620800",
+  "\u9152\u6CC9": "620900",
+  "\u5E86\u9633": "621000",
+  "\u5B9A\u897F": "621100",
+  "\u9647\u5357": "621200",
+  "\u4E34\u590F\u56DE\u65CF\u81EA\u6CBB\u5DDE": "622900",
+  "\u7518\u5357\u85CF\u65CF\u81EA\u6CBB\u5DDE": "623000",
+  // 青海省
+  "\u897F\u5B81": "630100",
+  "\u6D77\u4E1C": "630200",
+  "\u6D77\u5317\u85CF\u65CF\u81EA\u6CBB\u5DDE": "632200",
+  "\u9EC4\u5357\u85CF\u65CF\u81EA\u6CBB\u5DDE": "632300",
+  "\u6D77\u5357\u85CF\u65CF\u81EA\u6CBB\u5DDE": "632500",
+  "\u679C\u6D1B\u85CF\u65CF\u81EA\u6CBB\u5DDE": "632600",
+  "\u7389\u6811\u85CF\u65CF\u81EA\u6CBB\u5DDE": "632700",
+  "\u6D77\u897F\u8499\u53E4\u65CF\u85CF\u65CF\u81EA\u6CBB\u5DDE": "632800",
+  // 宁夏回族自治区
+  "\u94F6\u5DDD": "640100",
+  "\u77F3\u5634\u5C71": "640200",
+  "\u5434\u5FE0": "640300",
+  "\u56FA\u539F": "640400",
+  "\u4E2D\u536B": "640500",
+  // 新疆维吾尔自治区
+  "\u4E4C\u9C81\u6728\u9F50": "650100",
+  "\u514B\u62C9\u739B\u4F9D": "650200",
+  "\u5410\u9C81\u756A": "650400",
+  "\u54C8\u5BC6": "650500",
+  "\u660C\u5409\u56DE\u65CF\u81EA\u6CBB\u5DDE": "652300",
+  "\u535A\u5C14\u5854\u62C9\u8499\u53E4\u81EA\u6CBB\u5DDE": "652700",
+  "\u5DF4\u97F3\u90ED\u695E\u8499\u53E4\u81EA\u6CBB\u5DDE": "652800",
+  "\u963F\u514B\u82CF\u5730\u533A": "652900",
+  "\u514B\u5B5C\u52D2\u82CF\u67EF\u5C14\u514B\u5B5C\u81EA\u6CBB\u5DDE": "653000",
+  "\u5580\u4EC0\u5730\u533A": "653100",
+  "\u548C\u7530\u5730\u533A": "653200",
+  "\u4F0A\u7281\u54C8\u8428\u514B\u81EA\u6CBB\u5DDE": "654000",
+  "\u5854\u57CE\u5730\u533A": "654200",
+  "\u963F\u52D2\u6CF0\u5730\u533A": "654300"
+};
+function getCityAdcode(cityName) {
+  if (CITY_ADCODE_MAP[cityName]) {
+    return CITY_ADCODE_MAP[cityName];
   }
-  /**
-   * 判断模型提供商
-   */
-  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";
+  const normalized = cityName.replace(/[市省区]$/, "");
+  if (CITY_ADCODE_MAP[normalized]) {
+    return CITY_ADCODE_MAP[normalized];
   }
-  /**
-   * 获取 Provider
-   */
-  getProvider(model) {
-    const providerName = this.getModelProvider(model);
-    return this.providers.get(providerName);
+  for (const [name, code] of Object.entries(CITY_ADCODE_MAP)) {
+    if (name.startsWith(cityName) || cityName.startsWith(name.slice(0, 2))) {
+      return code;
+    }
   }
-  /**
-   * 构建系统提示词
-   */
-  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}
+  return null;
+}
 
-\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}`;
+// src/builtin-tools/weather/get-weather.ts
+var AMAP_KEY = "16924e39cfd78c645f0035c1bc290961";
+function getWeatherTool() {
+  return tool({
+    name: "get_weather",
+    description: "\u83B7\u53D6\u6307\u5B9A\u57CE\u5E02\u7684\u5B9E\u65F6\u5929\u6C14\u4FE1\u606F\u3002\u652F\u6301\u5168\u56FD 337 \u4E2A\u5730\u7EA7\u5E02\uFF0C\u5305\u62EC\uFF1A\u5317\u4EAC\u3001\u4E0A\u6D77\u3001\u5E7F\u5DDE\u3001\u6DF1\u5733\u3001\u676D\u5DDE\u3001\u6210\u90FD\u3001\u6B66\u6C49\u3001\u897F\u5B89\u3001\u5357\u4EAC\u3001\u82CF\u5DDE\u3001\u91CD\u5E86\u3001\u5929\u6D25\u7B49\u3002\u8FD4\u56DE\u6E29\u5EA6\u3001\u5929\u6C14\u72B6\u51B5\u3001\u6E7F\u5EA6\u3001\u98CE\u5411\u98CE\u529B\u7B49\u4FE1\u606F\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        city: {
+          type: "string",
+          description: '\u57CE\u5E02\u540D\u79F0\uFF0C\u5982 "\u5317\u4EAC"\u3001"\u4E0A\u6D77"\u3001"\u6DF1\u5733"\u3001"\u676D\u5DDE"'
+        }
+      },
+      required: ["city"]
+    },
+    execute: async (args, context) => {
+      const city = args.city;
+      if (context.signal?.aborted) {
+        return JSON.stringify({ success: false, error: "\u64CD\u4F5C\u5DF2\u53D6\u6D88", cancelled: true });
+      }
+      const adcode = getCityAdcode(city);
+      if (!adcode) {
+        return JSON.stringify({
+          error: `\u4E0D\u652F\u6301\u7684\u57CE\u5E02: ${city}`,
+          tip: "\u8BF7\u8F93\u5165\u5730\u7EA7\u5E02\u540D\u79F0\uFF0C\u5982\uFF1A\u5317\u4EAC\u3001\u4E0A\u6D77\u3001\u5E7F\u5DDE\u3001\u6DF1\u5733"
+        });
+      }
+      try {
+        const url = `https://restapi.amap.com/v3/weather/weatherInfo?key=${AMAP_KEY}&city=${adcode}&extensions=base&output=JSON`;
+        const response = await fetch(url, { signal: context.signal });
+        if (!response.ok) {
+          return JSON.stringify({ error: `\u5929\u6C14\u670D\u52A1\u8BF7\u6C42\u5931\u8D25: ${response.status}` });
+        }
+        const data = await response.json();
+        if (data.status !== "1" || data.infocode !== "10000") {
+          return JSON.stringify({ error: `\u5929\u6C14\u670D\u52A1\u8FD4\u56DE\u9519\u8BEF: ${data.info}` });
+        }
+        if (!data.lives?.length) {
+          return JSON.stringify({ error: "\u672A\u83B7\u53D6\u5230\u5929\u6C14\u6570\u636E" });
+        }
+        const live = data.lives[0];
+        return JSON.stringify({
+          city: live.city,
+          temperature: parseInt(live.temperature, 10),
+          condition: live.weather,
+          humidity: parseInt(live.humidity, 10),
+          wind: `${live.winddirection}\u98CE ${live.windpower}\u7EA7`,
+          reportTime: live.reporttime,
+          province: live.province
+        });
+      } catch (error) {
+        if (context.signal?.aborted) {
+          return JSON.stringify({ success: false, error: "\u64CD\u4F5C\u5DF2\u53D6\u6D88", cancelled: true });
+        }
+        return JSON.stringify({
+          success: false,
+          error: `\u83B7\u53D6\u5929\u6C14\u5931\u8D25: ${error instanceof Error ? error.message : "\u7F51\u7EDC\u9519\u8BEF"}`
+        });
       }
-      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;
+  });
+}
+
+// src/builtin-tools/ui-actions.ts
+function showToastTool() {
+  return tool({
+    name: "show_toast",
+    description: "\u5728\u7528\u6237\u754C\u9762\u4E0A\u663E\u793A\u4E00\u6761Toast \u901A\u77E5\u6D88\u606F\uFF0C\u7528\u4E8E\u544A\u77E5\u7528\u6237\u64CD\u4F5C\u7ED3\u679C\u6216\u91CD\u8981\u63D0\u793A\u4FE1\u606F\uFF0C\u6D88\u606F\u4F1A\u5728\u51E0\u79D2\u540E\u81EA\u52A8\u6D88\u5931",
+    parameters: {
+      type: "object",
+      properties: {
+        message: { type: "string", description: "\u8981\u663E\u793A\u7ED9\u7528\u6237\u7684\u901A\u77E5\u5185\u5BB9" }
+      },
+      required: ["message"]
+    },
+    execute: async (args) => {
+      const message = args.message;
+      return {
+        result: JSON.stringify({ success: true }),
+        sideEffects: [{ type: "notification", success: true, message }]
+      };
     }
-    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;
+  });
+}
+function openConfirmDialogTool() {
+  return tool({
+    name: "open_confirm_dialog",
+    description: "\u5728\u7528\u6237\u754C\u9762\u4E0A\u5F39\u51FA\u4E00\u4E2A\u6A21\u6001\u786E\u8BA4\u5BF9\u8BDD\u6846\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "\u5BF9\u8BDD\u6846\u6807\u9898\uFF0C\u7B80\u8981\u8BF4\u660E\u786E\u8BA4\u7684\u64CD\u4F5C" },
+        message: { type: "string", description: "\u8BE6\u7EC6\u63CF\u8FF0\u9700\u8981\u7528\u6237\u786E\u8BA4\u7684\u5185\u5BB9" },
+        confirmText: { type: "string", description: '\u786E\u8BA4\u6309\u94AE\u6587\u5B57\uFF0C\u9ED8\u8BA4\u4E3A"\u786E\u8BA4"' },
+        cancelText: { type: "string", description: '\u53D6\u6D88\u6309\u94AE\u6587\u5B57\uFF0C\u9ED8\u8BA4\u4E3A"\u53D6\u6D88"' }
+      },
+      required: ["title", "message"]
+    },
+    execute: async (args) => {
+      return {
+        result: JSON.stringify({ success: true }),
+        sideEffects: [{
+          type: "ui:confirm_dialog",
+          success: true,
+          data: {
+            title: args.title,
+            message: args.message,
+            confirmText: args.confirmText || "\u786E\u8BA4",
+            cancelText: args.cancelText || "\u53D6\u6D88"
+          }
+        }]
+      };
     }
-  }
-  /**
-   * 中断当前请求
-   */
-  abort() {
-    if (this.abortController) {
-      this.abortController.abort();
+  });
+}
+function openFilePreviewTool() {
+  return tool({
+    name: "open_file_preview",
+    description: "\u5728\u7528\u6237\u754C\u9762\u4E0A\u6253\u5F00\u6587\u4EF6\u9884\u89C8\u7A97\u53E3\uFF0C\u8BA9\u7528\u6237\u67E5\u770B\u6307\u5B9A\u6587\u4EF6\u7684\u5185\u5BB9\uFF0C\u652F\u6301\u6587\u672C\u3001\u56FE\u7247\u7B49\u5E38\u89C1\u683C\u5F0F",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\u8981\u9884\u89C8\u7684\u6587\u4EF6\u7684\u5B8C\u6574\u8DEF\u5F84" }
+      },
+      required: ["path"]
+    },
+    execute: async (args) => {
+      return {
+        result: JSON.stringify({ success: true, path: args.path }),
+        sideEffects: [{
+          type: "ui:file_preview",
+          success: true,
+          data: { path: args.path }
+        }]
+      };
     }
+  });
+}
+function navigateToDirectoryTool() {
+  return tool({
+    name: "navigate_to_directory",
+    description: "\u63A7\u5236\u7528\u6237\u754C\u9762\u5DE6\u4FA7\u7684\u6587\u4EF6\u6D4F\u89C8\u5668\u8DF3\u8F6C\u5230\u6307\u5B9A\u76EE\u5F55\uFF0C\u8BA9\u7528\u6237\u53EF\u4EE5\u76F4\u63A5\u770B\u5230\u8BE5\u76EE\u5F55\u4E0B\u7684\u6587\u4EF6\u5217\u8868",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\u8981\u8DF3\u8F6C\u5230\u7684\u76EE\u5F55\u7684\u5B8C\u6574\u8DEF\u5F84" }
+      },
+      required: ["path"]
+    },
+    execute: async (args) => {
+      return {
+        result: JSON.stringify({ success: true, path: args.path }),
+        sideEffects: [{
+          type: "ui:navigate",
+          success: true,
+          data: { path: args.path }
+        }]
+      };
+    }
+  });
+}
+var uiActionTools = [
+  showToastTool(),
+  openConfirmDialogTool(),
+  openFilePreviewTool(),
+  navigateToDirectoryTool()
+];
+
+// src/builtin-tools/search-documents.ts
+var aiSearchModule = null;
+async function loadAiSearch() {
+  if (aiSearchModule) return aiSearchModule;
+  try {
+    const dynamicRequire = new Function(
+      "moduleName",
+      "return import(moduleName)"
+    );
+    const mod = await dynamicRequire("@huyooo/ai-search");
+    aiSearchModule = mod;
+    return aiSearchModule;
+  } catch {
+    return null;
   }
-  /**
-   * 清空对话历史
-   */
-  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);
+}
+async function createDocumentSearchTools(options) {
+  const mod = await loadAiSearch();
+  if (!mod) {
+    return [createPlaceholderTool()];
   }
-  /**
-   * 获取所有支持的模型
-   */
-  getSupportedModels() {
-    return AVAILABLE_MODELS;
+  const dataDir = options?.dataDir || "./.search-data";
+  const plugin = await mod.searchPlugin({
+    dataDir,
+    // 如果配置了默认目录且自动索引，使用第一个目录作为工作空间
+    workspace: options?.autoIndex && options?.defaultDirectories?.length ? expandPath(options.defaultDirectories[0]) : void 0
+  });
+  return plugin.tools;
+}
+function createPlaceholderTool() {
+  return {
+    name: "search_local_documents",
+    description: "\u641C\u7D22\u672C\u5730\u6587\u6863\uFF08\u9700\u8981\u5B89\u88C5 @huyooo/ai-search\uFF09",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "\u641C\u7D22\u5185\u5BB9"
+        }
+      },
+      required: ["query"]
+    },
+    execute: async () => {
+      return JSON.stringify({
+        error: "\u6587\u6863\u641C\u7D22\u529F\u80FD\u672A\u542F\u7528",
+        solution: "\u8BF7\u5B89\u88C5 @huyooo/ai-search: npm install @huyooo/ai-search"
+      });
+    }
+  };
+}
+function expandPath(p) {
+  if (p.startsWith("~")) {
+    return p.replace("~", process.env.HOME || "");
   }
-};
+  return p;
+}
+async function getDocumentSearchInstance(dataDir = "./.search-data", workspace) {
+  const mod = await loadAiSearch();
+  if (!mod) return null;
+  return await mod.searchPlugin({ dataDir, workspace });
+}
 
-exports.AVAILABLE_MODELS = AVAILABLE_MODELS;
-exports.ArkProvider = ArkProvider;
-exports.GeminiProvider = GeminiProvider;
+exports.ARK_MODELS = ARK_MODELS;
+exports.ArkAdapter = ArkAdapter;
+exports.ChatOrchestrator = ChatOrchestrator;
+exports.DEFAULT_MODEL = DEFAULT_MODEL;
+exports.GEMINI_MODELS = GEMINI_MODELS;
+exports.GeminiAdapter = GeminiAdapter;
 exports.HybridAgent = HybridAgent;
-exports.OpenRouterProvider = OpenRouterProvider;
-exports.QwenProvider = QwenProvider;
+exports.MODELS = MODELS;
+exports.OPENROUTER_MODELS = OPENROUTER_MODELS;
+exports.OpenRouterAdapter = OpenRouterAdapter;
+exports.QWEN_MODELS = QWEN_MODELS;
+exports.QwenAdapter = QwenAdapter;
+exports.analyzeImageTool = analyzeImageTool;
+exports.analyzeVideoTool = analyzeVideoTool;
+exports.createAbort = createAbort;
+exports.createApiError = createApiError;
+exports.createArkAdapter = createArkAdapter;
 exports.createDefaultToolExecutor = createDefaultToolExecutor;
-exports.createToolDefinitions = createToolDefinitions;
+exports.createDocumentSearchTools = createDocumentSearchTools;
+exports.createDone = createDone;
+exports.createError = createError;
+exports.createGeminiAdapter = createGeminiAdapter;
+exports.createImage = createImage;
+exports.createOpenRouterAdapter = createOpenRouterAdapter;
+exports.createOrchestrator = createOrchestrator;
+exports.createParseError = createParseError;
+exports.createQwenAdapter = createQwenAdapter;
+exports.createRateLimitError = createRateLimitError;
+exports.createSearchEnd = createSearchEnd;
+exports.createSearchResult = createSearchResult;
+exports.createSearchStart = createSearchStart;
+exports.createStepEnd = createStepEnd;
+exports.createStepStart = createStepStart;
+exports.createStreamStart = createStreamStart;
+exports.createTextDelta = createTextDelta;
+exports.createThinkingDelta = createThinkingDelta;
+exports.createThinkingEnd = createThinkingEnd;
+exports.createThinkingStart = createThinkingStart;
+exports.createTimeoutError = createTimeoutError;
+exports.createToolCallResult = createToolCallResult;
+exports.createToolCallStart = createToolCallStart;
+exports.createToolError = createToolError;
+exports.createVideo = createVideo;
+exports.executeCommandTool = executeCommandTool;
+exports.generateImageTool = generateImageTool;
+exports.getCwdTool = getCwdTool;
+exports.getDefaultProvider = getDefaultProvider;
+exports.getDocumentSearchInstance = getDocumentSearchInstance;
+exports.getModelByModelId = getModelByModelId;
+exports.getNativeModels = getNativeModels;
+exports.getOpenRouterModels = getOpenRouterModels;
+exports.getPlatformTool = getPlatformTool;
+exports.getRouteRules = getRouteRules;
+exports.getWeatherTool = getWeatherTool;
+exports.isAbortEvent = isAbortEvent;
+exports.isErrorEvent = isErrorEvent;
+exports.isMediaEvent = isMediaEvent;
+exports.isModelForProvider = isModelForProvider;
+exports.isRetryableError = isRetryableError;
+exports.isSearchEvent = isSearchEvent;
+exports.isStatusEvent = isStatusEvent;
+exports.isStepEvent = isStepEvent;
+exports.isTextEvent = isTextEvent;
+exports.isThinkingEvent = isThinkingEvent;
+exports.isToolEvent = isToolEvent;
+exports.navigateToDirectoryTool = navigateToDirectoryTool;
+exports.openConfirmDialogTool = openConfirmDialogTool;
+exports.openFilePreviewTool = openFilePreviewTool;
+exports.resolveTools = resolveTools;
+exports.routeModelToProvider = routeModelToProvider;
+exports.routeModelWithDetails = routeModelWithDetails;
+exports.showToastTool = showToastTool;
+exports.tool = tool;
+exports.tools = tools;
+exports.uiActionTools = uiActionTools;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map