@aituber-onair/chat 0.32.0 → 0.34.0

package/dist/umd/aituber-onair-chat.js

@@ -27,21 +27,30 @@ var AITuberOnAirChat = (() => {
     ChatServiceHttpClient: () => ChatServiceHttpClient,
     ClaudeChatService: () => ClaudeChatService,
     ClaudeChatServiceProvider: () => ClaudeChatServiceProvider,
+    DEEPSEEK_API_BASE_URL: () => DEEPSEEK_API_BASE_URL,
+    DEEPSEEK_DEPRECATED_MODELS: () => DEEPSEEK_DEPRECATED_MODELS,
+    DEEPSEEK_SUPPORTED_MODELS: () => DEEPSEEK_SUPPORTED_MODELS,
     DEFAULT_MAX_TOKENS: () => DEFAULT_MAX_TOKENS,
     DEFAULT_SUMMARY_PROMPT_TEMPLATE: () => DEFAULT_SUMMARY_PROMPT_TEMPLATE,
     DEFAULT_VISION_PROMPT: () => DEFAULT_VISION_PROMPT,
+    DeepSeekChatService: () => DeepSeekChatService,
+    DeepSeekChatServiceProvider: () => DeepSeekChatServiceProvider,
     EMOTION_TAG_CLEANUP_REGEX: () => EMOTION_TAG_CLEANUP_REGEX,
     EMOTION_TAG_REGEX: () => EMOTION_TAG_REGEX,
     ENDPOINT_CLAUDE_API: () => ENDPOINT_CLAUDE_API,
+    ENDPOINT_DEEPSEEK_CHAT_COMPLETIONS_API: () => ENDPOINT_DEEPSEEK_CHAT_COMPLETIONS_API,
     ENDPOINT_GEMINI_API: () => ENDPOINT_GEMINI_API,
     ENDPOINT_KIMI_CHAT_COMPLETIONS_API: () => ENDPOINT_KIMI_CHAT_COMPLETIONS_API,
+    ENDPOINT_MISTRAL_CHAT_COMPLETIONS_API: () => ENDPOINT_MISTRAL_CHAT_COMPLETIONS_API,
     ENDPOINT_OPENAI_CHAT_COMPLETIONS_API: () => ENDPOINT_OPENAI_CHAT_COMPLETIONS_API,
     ENDPOINT_OPENAI_RESPONSES_API: () => ENDPOINT_OPENAI_RESPONSES_API,
     ENDPOINT_OPENROUTER_API: () => ENDPOINT_OPENROUTER_API,
     ENDPOINT_XAI_CHAT_COMPLETIONS_API: () => ENDPOINT_XAI_CHAT_COMPLETIONS_API,
     ENDPOINT_ZAI_CHAT_COMPLETIONS_API: () => ENDPOINT_ZAI_CHAT_COMPLETIONS_API,
     EmotionParser: () => EmotionParser,
+    GEMINI_DEPRECATED_MODELS: () => GEMINI_DEPRECATED_MODELS,
     GEMINI_NANO_MAX_CONTEXT_MESSAGES: () => GEMINI_NANO_MAX_CONTEXT_MESSAGES,
+    GEMINI_RECOMMENDED_MODELS: () => GEMINI_RECOMMENDED_MODELS,
     GEMINI_VISION_SUPPORTED_MODELS: () => GEMINI_VISION_SUPPORTED_MODELS,
     GPT5_PRESETS: () => GPT5_PRESETS,
     GPT_5_MODELS: () => GPT_5_MODELS,
@@ -54,6 +63,10 @@ var AITuberOnAirChat = (() => {
     KimiChatService: () => KimiChatService,
     KimiChatServiceProvider: () => KimiChatServiceProvider,
     MAX_TOKENS_BY_LENGTH: () => MAX_TOKENS_BY_LENGTH,
+    MISTRAL_API_BASE_URL: () => MISTRAL_API_BASE_URL,
+    MISTRAL_REASONING_EFFORT_SUPPORTED_MODELS: () => MISTRAL_REASONING_EFFORT_SUPPORTED_MODELS,
+    MISTRAL_SUPPORTED_MODELS: () => MISTRAL_SUPPORTED_MODELS,
+    MISTRAL_VISION_SUPPORTED_MODELS: () => MISTRAL_VISION_SUPPORTED_MODELS,
     MODEL_ANTHROPIC_CLAUDE_3_5_SONNET: () => MODEL_ANTHROPIC_CLAUDE_3_5_SONNET,
     MODEL_ANTHROPIC_CLAUDE_3_7_SONNET: () => MODEL_ANTHROPIC_CLAUDE_3_7_SONNET,
     MODEL_ANTHROPIC_CLAUDE_4_5_HAIKU: () => MODEL_ANTHROPIC_CLAUDE_4_5_HAIKU,
@@ -73,12 +86,17 @@ var AITuberOnAirChat = (() => {
     MODEL_CLAUDE_4_7_OPUS: () => MODEL_CLAUDE_4_7_OPUS,
     MODEL_CLAUDE_4_OPUS: () => MODEL_CLAUDE_4_OPUS,
     MODEL_CLAUDE_4_SONNET: () => MODEL_CLAUDE_4_SONNET,
+    MODEL_DEEPSEEK_CHAT: () => MODEL_DEEPSEEK_CHAT,
+    MODEL_DEEPSEEK_REASONER: () => MODEL_DEEPSEEK_REASONER,
+    MODEL_DEEPSEEK_V4_FLASH: () => MODEL_DEEPSEEK_V4_FLASH,
+    MODEL_DEEPSEEK_V4_PRO: () => MODEL_DEEPSEEK_V4_PRO,
     MODEL_GEMINI_2_0_FLASH: () => MODEL_GEMINI_2_0_FLASH,
     MODEL_GEMINI_2_0_FLASH_LITE: () => MODEL_GEMINI_2_0_FLASH_LITE,
     MODEL_GEMINI_2_5_FLASH: () => MODEL_GEMINI_2_5_FLASH,
     MODEL_GEMINI_2_5_FLASH_LITE: () => MODEL_GEMINI_2_5_FLASH_LITE,
     MODEL_GEMINI_2_5_FLASH_LITE_PREVIEW_06_17: () => MODEL_GEMINI_2_5_FLASH_LITE_PREVIEW_06_17,
     MODEL_GEMINI_2_5_PRO: () => MODEL_GEMINI_2_5_PRO,
+    MODEL_GEMINI_3_1_FLASH_LITE: () => MODEL_GEMINI_3_1_FLASH_LITE,
     MODEL_GEMINI_3_1_FLASH_LITE_PREVIEW: () => MODEL_GEMINI_3_1_FLASH_LITE_PREVIEW,
     MODEL_GEMINI_3_1_PRO_PREVIEW: () => MODEL_GEMINI_3_1_PRO_PREVIEW,
     MODEL_GEMINI_3_FLASH_PREVIEW: () => MODEL_GEMINI_3_FLASH_PREVIEW,
@@ -122,6 +140,12 @@ var AITuberOnAirChat = (() => {
     MODEL_GROK_4_3: () => MODEL_GROK_4_3,
     MODEL_KIMI_K2_5: () => MODEL_KIMI_K2_5,
     MODEL_KIMI_K2_6: () => MODEL_KIMI_K2_6,
+    MODEL_MISTRAL_LARGE_2512: () => MODEL_MISTRAL_LARGE_2512,
+    MODEL_MISTRAL_LARGE_LATEST: () => MODEL_MISTRAL_LARGE_LATEST,
+    MODEL_MISTRAL_MEDIUM_2508: () => MODEL_MISTRAL_MEDIUM_2508,
+    MODEL_MISTRAL_MEDIUM_3_5: () => MODEL_MISTRAL_MEDIUM_3_5,
+    MODEL_MISTRAL_SMALL_2603: () => MODEL_MISTRAL_SMALL_2603,
+    MODEL_MISTRAL_SMALL_LATEST: () => MODEL_MISTRAL_SMALL_LATEST,
     MODEL_MOONSHOTAI_KIMI_K2_5: () => MODEL_MOONSHOTAI_KIMI_K2_5,
     MODEL_MOONSHOTAI_KIMI_LATEST: () => MODEL_MOONSHOTAI_KIMI_LATEST,
     MODEL_O1: () => MODEL_O1,
@@ -142,6 +166,8 @@ var AITuberOnAirChat = (() => {
     MODEL_ZAI_GLM_4_5_AIR: () => MODEL_ZAI_GLM_4_5_AIR,
     MODEL_ZAI_GLM_4_5_AIR_FREE: () => MODEL_ZAI_GLM_4_5_AIR_FREE,
     MODEL_ZAI_GLM_4_7_FLASH: () => MODEL_ZAI_GLM_4_7_FLASH,
+    MistralChatService: () => MistralChatService,
+    MistralChatServiceProvider: () => MistralChatServiceProvider,
     OPENROUTER_CREDITS_THRESHOLD: () => OPENROUTER_CREDITS_THRESHOLD,
     OPENROUTER_FREE_DAILY_LIMIT_HIGH_CREDITS: () => OPENROUTER_FREE_DAILY_LIMIT_HIGH_CREDITS,
     OPENROUTER_FREE_DAILY_LIMIT_LOW_CREDITS: () => OPENROUTER_FREE_DAILY_LIMIT_LOW_CREDITS,
@@ -171,6 +197,9 @@ var AITuberOnAirChat = (() => {
     installGASFetch: () => installGASFetch,
     isGPT5Model: () => isGPT5Model,
     isKimiVisionModel: () => isKimiVisionModel,
+    isMistralReasoningEffort: () => isMistralReasoningEffort,
+    isMistralReasoningEffortModel: () => isMistralReasoningEffortModel,
+    isMistralVisionModel: () => isMistralVisionModel,
     isOpenRouterFreeModel: () => isOpenRouterFreeModel,
     isOpenRouterVisionModel: () => isOpenRouterVisionModel,
     isResponsesOnlyGPT5Model: () => isResponsesOnlyGPT5Model,
@@ -268,6 +297,7 @@ var AITuberOnAirChat = (() => {
   var MODEL_GEMMA_4_31B_IT = "gemma-4-31b-it";
   var MODEL_GEMMA_4_26B_A4B_IT = "gemma-4-26b-a4b-it";
   var MODEL_GEMINI_3_1_PRO_PREVIEW = "gemini-3.1-pro-preview";
+  var MODEL_GEMINI_3_1_FLASH_LITE = "gemini-3.1-flash-lite";
   var MODEL_GEMINI_3_1_FLASH_LITE_PREVIEW = "gemini-3.1-flash-lite-preview";
   var MODEL_GEMINI_3_PRO_PREVIEW = "gemini-3-pro-preview";
   var MODEL_GEMINI_3_FLASH_PREVIEW = "gemini-3-flash-preview";
@@ -277,20 +307,27 @@ var AITuberOnAirChat = (() => {
   var MODEL_GEMINI_2_5_FLASH_LITE_PREVIEW_06_17 = "gemini-2.5-flash-lite-preview-06-17";
   var MODEL_GEMINI_2_0_FLASH = "gemini-2.0-flash";
   var MODEL_GEMINI_2_0_FLASH_LITE = "gemini-2.0-flash-lite";
-  var GEMINI_VISION_SUPPORTED_MODELS = [
-    MODEL_GEMMA_4_31B_IT,
-    MODEL_GEMMA_4_26B_A4B_IT,
+  var GEMINI_RECOMMENDED_MODELS = [
+    MODEL_GEMINI_3_1_FLASH_LITE,
     MODEL_GEMINI_3_1_PRO_PREVIEW,
-    MODEL_GEMINI_3_1_FLASH_LITE_PREVIEW,
-    MODEL_GEMINI_3_PRO_PREVIEW,
     MODEL_GEMINI_3_FLASH_PREVIEW,
     MODEL_GEMINI_2_5_PRO,
     MODEL_GEMINI_2_5_FLASH,
     MODEL_GEMINI_2_5_FLASH_LITE,
+    MODEL_GEMMA_4_31B_IT,
+    MODEL_GEMMA_4_26B_A4B_IT
+  ];
+  var GEMINI_DEPRECATED_MODELS = [
+    MODEL_GEMINI_3_1_FLASH_LITE_PREVIEW,
+    MODEL_GEMINI_3_PRO_PREVIEW,
     MODEL_GEMINI_2_5_FLASH_LITE_PREVIEW_06_17,
     MODEL_GEMINI_2_0_FLASH,
     MODEL_GEMINI_2_0_FLASH_LITE
   ];
+  var GEMINI_VISION_SUPPORTED_MODELS = [
+    ...GEMINI_RECOMMENDED_MODELS,
+    ...GEMINI_DEPRECATED_MODELS
+  ];
 
   // src/constants/claude.ts
   var ENDPOINT_CLAUDE_API = "https://api.anthropic.com/v1/messages";
@@ -443,6 +480,61 @@ var AITuberOnAirChat = (() => {
     return KIMI_VISION_SUPPORTED_MODELS.includes(model);
   }
 
+  // src/constants/deepseek.ts
+  var DEEPSEEK_API_BASE_URL = "https://api.deepseek.com";
+  var ENDPOINT_DEEPSEEK_CHAT_COMPLETIONS_API = `${DEEPSEEK_API_BASE_URL}/chat/completions`;
+  var MODEL_DEEPSEEK_V4_FLASH = "deepseek-v4-flash";
+  var MODEL_DEEPSEEK_V4_PRO = "deepseek-v4-pro";
+  var MODEL_DEEPSEEK_CHAT = "deepseek-chat";
+  var MODEL_DEEPSEEK_REASONER = "deepseek-reasoner";
+  var DEEPSEEK_SUPPORTED_MODELS = [
+    MODEL_DEEPSEEK_V4_FLASH,
+    MODEL_DEEPSEEK_V4_PRO
+  ];
+  var DEEPSEEK_DEPRECATED_MODELS = [
+    MODEL_DEEPSEEK_CHAT,
+    MODEL_DEEPSEEK_REASONER
+  ];
+
+  // src/constants/mistral.ts
+  var MISTRAL_API_BASE_URL = "https://api.mistral.ai/v1";
+  var ENDPOINT_MISTRAL_CHAT_COMPLETIONS_API = `${MISTRAL_API_BASE_URL}/chat/completions`;
+  var MODEL_MISTRAL_SMALL_LATEST = "mistral-small-latest";
+  var MODEL_MISTRAL_SMALL_2603 = "mistral-small-2603";
+  var MODEL_MISTRAL_MEDIUM_3_5 = "mistral-medium-3-5";
+  var MODEL_MISTRAL_MEDIUM_2508 = "mistral-medium-2508";
+  var MODEL_MISTRAL_LARGE_LATEST = "mistral-large-latest";
+  var MODEL_MISTRAL_LARGE_2512 = "mistral-large-2512";
+  var MISTRAL_SUPPORTED_MODELS = [
+    MODEL_MISTRAL_SMALL_LATEST,
+    MODEL_MISTRAL_MEDIUM_3_5,
+    MODEL_MISTRAL_LARGE_LATEST,
+    MODEL_MISTRAL_LARGE_2512,
+    MODEL_MISTRAL_SMALL_2603,
+    MODEL_MISTRAL_MEDIUM_2508
+  ];
+  var MISTRAL_REASONING_EFFORT_SUPPORTED_MODELS = [
+    MODEL_MISTRAL_SMALL_LATEST,
+    MODEL_MISTRAL_MEDIUM_3_5
+  ];
+  var MISTRAL_VISION_SUPPORTED_MODELS = [
+    MODEL_MISTRAL_SMALL_LATEST,
+    MODEL_MISTRAL_SMALL_2603,
+    MODEL_MISTRAL_MEDIUM_3_5,
+    MODEL_MISTRAL_MEDIUM_2508,
+    MODEL_MISTRAL_LARGE_LATEST,
+    MODEL_MISTRAL_LARGE_2512
+  ];
+  function isMistralReasoningEffortModel(model) {
+    return MISTRAL_REASONING_EFFORT_SUPPORTED_MODELS.includes(model);
+  }
+  function isMistralReasoningEffort(effort) {
+    return effort === "none" || effort === "high";
+  }
+  function isMistralVisionModel(model) {
+    return MISTRAL_VISION_SUPPORTED_MODELS.includes(model);
+  }
+
   // src/constants/chat.ts
   var CHAT_RESPONSE_LENGTH = {
     VERY_SHORT: "veryShort",
@@ -756,6 +848,23 @@ If it's in another language, summarize in that language.
       throw error;
     }
   };
+  var extractTextContent = (content) => {
+    if (typeof content === "string") {
+      return content;
+    }
+    if (!Array.isArray(content)) {
+      return "";
+    }
+    return content.map((chunk) => {
+      if (typeof chunk === "string") {
+        return chunk;
+      }
+      if (chunk && typeof chunk === "object" && chunk.type === "text" && typeof chunk.text === "string") {
+        return chunk.text;
+      }
+      return "";
+    }).join("");
+  };
   var forEachSsePayload = async (res, onPayload) => {
     const reader = res.body?.getReader();
     if (!reader) {
@@ -788,7 +897,7 @@ If it's in another language, summarize in that language.
     await forEachSsePayload(res, (payload) => {
       const json = parseJsonPayload(payload, options.onJsonError);
       if (!json) return;
-      const content = json.choices?.[0]?.delta?.content || "";
+      const content = extractTextContent(json.choices?.[0]?.delta?.content);
       if (content) {
         onPartial(content);
         full += content;
@@ -813,9 +922,10 @@ If it's in another language, summarize in that language.
         usage = json.usage;
       }
       const delta = choice?.delta;
-      if (delta?.content) {
-        onPartial(delta.content);
-        appendTextBlock(textBlocks, delta.content);
+      const content = extractTextContent(delta?.content);
+      if (content) {
+        onPartial(content);
+        appendTextBlock(textBlocks, content);
       }
       if (delta?.tool_calls) {
         delta.tool_calls.forEach((c) => {
@@ -856,8 +966,11 @@ If it's in another language, summarize in that language.
           input: JSON.parse(c.function?.arguments || "{}")
         })
       );
-    } else if (choice?.message?.content) {
-      blocks.push({ type: "text", text: choice.message.content });
+    } else {
+      const content = extractTextContent(choice?.message?.content);
+      if (content) {
+        blocks.push({ type: "text", text: content });
+      }
     }
     return {
       blocks,
@@ -1660,171 +1773,210 @@ If it's in another language, summarize in that language.
     }
   };
 
-  // src/utils/mcpSchemaFetcher.ts
-  var MCPSchemaFetcher = class {
-    /**
-     * Fetch tool schemas from MCP server
-     * @param serverConfig MCP server configuration
-     * @returns Array of tool definitions
-     */
-    static async fetchToolSchemas(serverConfig) {
-      try {
-        const headers = {
-          "Content-Type": "application/json"
-        };
-        if (serverConfig.authorization_token) {
-          headers["Authorization"] = `Bearer ${serverConfig.authorization_token}`;
-        }
-        const response = await ChatServiceHttpClient.post(
-          `${serverConfig.url}/tools`,
-          {},
-          headers
-        );
-        const toolsData = await response.json();
-        if (Array.isArray(toolsData.tools)) {
-          return toolsData.tools.map((tool) => ({
-            name: `mcp_${serverConfig.name}_${tool.name}`,
-            description: tool.description || `Tool from ${serverConfig.name} MCP server`,
-            parameters: tool.inputSchema || {
-              type: "object",
-              properties: {},
-              required: []
-            }
-          }));
-        }
-        return [
-          {
-            name: `mcp_${serverConfig.name}_search`,
-            description: `Search using ${serverConfig.name} MCP server`,
-            parameters: {
-              type: "object",
-              properties: {
-                query: {
-                  type: "string",
-                  description: "Search query"
+  // src/services/providers/openai/responsesParser.ts
+  async function parseOpenAIResponsesStream(res, onPartial) {
+    const reader = res.body.getReader();
+    const dec = new TextDecoder();
+    const textBlocks = [];
+    const toolCallsMap = /* @__PURE__ */ new Map();
+    let responseStatus;
+    let incompleteDetails;
+    let usage;
+    let buf = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += dec.decode(value, { stream: true });
+      let eventType = "";
+      let eventData = "";
+      const lines = buf.split("\n");
+      buf = lines.pop() || "";
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith("event:")) {
+          eventType = line.slice(6).trim();
+        } else if (line.startsWith("data:")) {
+          eventData = line.slice(5).trim();
+        } else if (line === "" && eventType && eventData) {
+          try {
+            const json = JSON.parse(eventData);
+            handleResponsesSSEEvent(
+              eventType,
+              json,
+              onPartial,
+              textBlocks,
+              toolCallsMap,
+              (metadata) => {
+                if (metadata.responseStatus !== void 0) {
+                  responseStatus = metadata.responseStatus;
                 }
-              },
-              required: ["query"]
-            }
-          }
-        ];
-      } catch (error) {
-        console.warn(
-          `Failed to fetch MCP schemas from ${serverConfig.name}:`,
-          error
-        );
-        return [
-          {
-            name: `mcp_${serverConfig.name}_search`,
-            description: `Search using ${serverConfig.name} MCP server (schema fetch failed)`,
-            parameters: {
-              type: "object",
-              properties: {
-                query: {
-                  type: "string",
-                  description: "Search query"
+                if (metadata.incompleteDetails !== void 0) {
+                  incompleteDetails = metadata.incompleteDetails;
                 }
-              },
-              required: ["query"]
-            }
+                if (metadata.usage !== void 0) {
+                  usage = metadata.usage;
+                }
+              }
+            );
+          } catch {
+            console.warn("Failed to parse SSE data:", eventData);
           }
-        ];
-      }
-    }
-    /**
-     * Fetch all tool schemas from multiple MCP servers
-     * @param mcpServers Array of MCP server configurations
-     * @returns Array of all tool definitions
-     */
-    static async fetchAllToolSchemas(mcpServers) {
-      const allSchemas = [];
-      for (const server of mcpServers) {
-        try {
-          const schemas = await this.fetchToolSchemas(server);
-          allSchemas.push(...schemas);
-        } catch (error) {
-          console.error(`Failed to fetch schemas from ${server.name}:`, error);
+          eventType = "";
+          eventData = "";
         }
       }
-      return allSchemas;
     }
-  };
-
-  // src/services/providers/gemini/GeminiChatService.ts
-  var GeminiChatService = class {
-    /**
-     * Constructor
-     * @param apiKey Google API key
-     * @param model Name of the model to use
-     * @param visionModel Name of the vision model
-     * @param tools Array of tool definitions
-     * @param mcpServers Array of MCP server configurations
-     */
-    constructor(apiKey, model = MODEL_GEMINI_2_0_FLASH_LITE, visionModel = MODEL_GEMINI_2_0_FLASH_LITE, tools = [], mcpServers = [], responseLength) {
-      /** Provider name */
-      this.provider = "gemini";
-      this.mcpToolSchemas = [];
-      this.mcpSchemasInitialized = false;
-      /** id(OpenAI) → name(Gemini) mapping */
-      this.callIdMap = /* @__PURE__ */ new Map();
-      this.apiKey = apiKey;
-      this.model = model;
-      this.responseLength = responseLength;
-      if (!GEMINI_VISION_SUPPORTED_MODELS.includes(visionModel)) {
-        throw new Error(
-          `Model ${visionModel} does not support vision capabilities.`
-        );
+    const toolBlocks = Array.from(toolCallsMap.values()).map(
+      (tool) => ({
+        type: "tool_use",
+        id: tool.id,
+        name: tool.name,
+        input: tool.input || {}
+      })
+    );
+    return {
+      blocks: [...textBlocks, ...toolBlocks],
+      stop_reason: toolBlocks.length ? "tool_use" : "end",
+      truncated: responseStatus === "incomplete",
+      response_status: responseStatus,
+      incomplete_details: incompleteDetails,
+      usage
+    };
+  }
+  function handleResponsesSSEEvent(eventType, data, onPartial, textBlocks, toolCallsMap, onMetadata) {
+    switch (eventType) {
+      case "response.output_item.added":
+        if (data.item?.type === "message" && Array.isArray(data.item.content)) {
+          data.item.content.forEach((c) => {
+            if (c.type === "output_text" && c.text) {
+              onPartial(c.text);
+              StreamTextAccumulator.append(textBlocks, c.text);
+            }
+          });
+        } else if (data.item?.type === "function_call") {
+          toolCallsMap.set(data.item.id, {
+            id: data.item.id,
+            name: data.item.name,
+            input: data.item.arguments ? JSON.parse(data.item.arguments) : {}
+          });
+        }
+        break;
+      case "response.content_part.added":
+        if (data.part?.type === "output_text" && typeof data.part.text === "string") {
+          onPartial(data.part.text);
+          StreamTextAccumulator.append(textBlocks, data.part.text);
+        }
+        break;
+      case "response.output_text.delta":
+      case "response.content_part.delta": {
+        const deltaText = typeof data.delta === "string" ? data.delta : data.delta?.text ?? "";
+        if (deltaText) {
+          onPartial(deltaText);
+          StreamTextAccumulator.append(textBlocks, deltaText);
+        }
+        break;
       }
-      this.visionModel = visionModel;
-      this.tools = tools;
-      this.mcpServers = mcpServers;
+      case "response.output_text.done":
+      case "response.content_part.done":
+      case "response.reasoning.started":
+      case "response.reasoning.delta":
+      case "response.reasoning.done":
+        break;
+      case "response.completed":
+        onMetadata(extractResponsesMetadata(data, "completed"));
+        break;
+      case "response.incomplete":
+        onMetadata(extractResponsesMetadata(data, "incomplete"));
+        break;
+      default:
+        break;
     }
-    /* ────────────────────────────────── */
-    /*  Utilities                           */
-    /* ────────────────────────────────── */
-    safeJsonParse(str) {
-      try {
-        return JSON.parse(str);
-      } catch {
-        return str;
-      }
-    }
-    normalizeToolResult(val) {
-      if (val === null) return { content: null };
-      if (typeof val === "object") return val;
-      return { content: val };
-    }
-    isGemma4Model(model) {
-      return /^gemma-4-/.test(model);
-    }
-    shouldExposeTextPart(part, model) {
-      if (!part.text) return false;
-      if (this.isGemma4Model(model) && part.thought === true) {
-        return false;
-      }
-      return true;
+  }
+  function extractResponsesMetadata(data, fallbackStatus) {
+    const response = data?.response ?? data;
+    return {
+      responseStatus: response?.status ?? fallbackStatus,
+      incompleteDetails: response?.incomplete_details ?? null,
+      usage: response?.usage
+    };
+  }
+  function parseOpenAIResponsesOneShot(data) {
+    const blocks = [];
+    if (data.output && Array.isArray(data.output)) {
+      data.output.forEach((outputItem) => {
+        if (outputItem.type === "message" && outputItem.content) {
+          outputItem.content.forEach((content) => {
+            if (content.type === "output_text" && content.text) {
+              blocks.push({ type: "text", text: content.text });
+            }
+          });
+        }
+        if (outputItem.type === "function_call") {
+          blocks.push({
+            type: "tool_use",
+            id: outputItem.id,
+            name: outputItem.name,
+            input: outputItem.arguments ? JSON.parse(outputItem.arguments) : {}
+          });
+        }
+      });
     }
+    return {
+      blocks,
+      stop_reason: blocks.some((b) => b.type === "tool_use") ? "tool_use" : "end",
+      truncated: data?.status === "incomplete",
+      response_status: data?.status,
+      incomplete_details: data?.incomplete_details ?? null,
+      usage: data?.usage
+    };
+  }
+
+  // src/services/providers/openai/OpenAIChatService.ts
+  var GPT5_RESPONSE_LENGTH_MIN_TOKENS = {
+    [CHAT_RESPONSE_LENGTH.VERY_SHORT]: 800,
+    [CHAT_RESPONSE_LENGTH.SHORT]: 1200,
+    [CHAT_RESPONSE_LENGTH.MEDIUM]: 2e3,
+    [CHAT_RESPONSE_LENGTH.LONG]: 3e3,
+    [CHAT_RESPONSE_LENGTH.VERY_LONG]: 8e3,
+    [CHAT_RESPONSE_LENGTH.DEEP]: 25e3
+  };
+  var GPT5_REASONING_MIN_TOKENS = {
+    none: 1200,
+    minimal: 1600,
+    low: 2500,
+    medium: 4e3,
+    high: 8e3,
+    xhigh: 12e3
+  };
+  var OPENAI_COMPATIBLE_CHAT_COMPLETIONS_PROVIDERS = /* @__PURE__ */ new Set([
+    "openai-compatible",
+    "deepseek",
+    "mistral"
+  ]);
+  var OpenAIChatService = class {
     /**
-     * camelCase → snake_case conversion (v1beta)
+     * Constructor
+     * @param apiKey OpenAI API key
+     * @param model Name of the model to use
+     * @param visionModel Name of the vision model
      */
-    adaptKeysForApi(obj) {
-      const map = {
-        toolConfig: "tool_config",
-        functionCallingConfig: "function_calling_config",
-        functionDeclarations: "function_declarations",
-        functionCall: "function_call",
-        functionResponse: "function_response"
-      };
-      if (Array.isArray(obj)) return obj.map((v) => this.adaptKeysForApi(v));
-      if (obj && typeof obj === "object") {
-        return Object.fromEntries(
-          Object.entries(obj).map(([k, v]) => [
-            map[k] ?? k,
-            this.adaptKeysForApi(v)
-          ])
+    constructor(apiKey, model = MODEL_GPT_4O_MINI, visionModel = MODEL_GPT_4O_MINI, tools, endpoint = ENDPOINT_OPENAI_CHAT_COMPLETIONS_API, mcpServers = [], responseLength, verbosity, reasoning_effort, enableReasoningSummary = false, provider = "openai", validateVisionModel = true) {
+      this.provider = provider;
+      this.apiKey = apiKey;
+      this.model = model;
+      this.tools = tools || [];
+      this.endpoint = endpoint;
+      this.mcpServers = mcpServers;
+      this.responseLength = responseLength;
+      this.verbosity = verbosity;
+      this.reasoning_effort = reasoning_effort;
+      this.enableReasoningSummary = enableReasoningSummary;
+      if (validateVisionModel && !VISION_SUPPORTED_MODELS.includes(visionModel)) {
+        throw new Error(
+          `Model ${visionModel} does not support vision capabilities.`
         );
       }
-      return obj;
+      this.visionModel = visionModel;
     }
     /**
      * Get the current model name
@@ -1841,1262 +1993,1383 @@ If it's in another language, summarize in that language.
       return this.visionModel;
     }
     /**
-     * Get configured MCP servers
-     * @returns Array of MCP server configurations
-     */
-    getMCPServers() {
-      return this.mcpServers;
-    }
-    /**
-     * Add MCP server configuration
-     * @param serverConfig MCP server configuration
-     */
-    addMCPServer(serverConfig) {
-      this.mcpServers.push(serverConfig);
-      this.mcpSchemasInitialized = false;
-    }
-    /**
-     * Remove MCP server by name
-     * @param serverName Name of the server to remove
-     */
-    removeMCPServer(serverName) {
-      this.mcpServers = this.mcpServers.filter(
-        (server) => server.name !== serverName
-      );
-      this.mcpSchemasInitialized = false;
-    }
-    /**
-     * Check if MCP servers are configured
-     * @returns True if MCP servers are configured
-     */
-    hasMCPServers() {
-      return this.mcpServers.length > 0;
-    }
-    /**
-     * Initialize MCP tool schemas by fetching from servers
-     * @private
+     * Process chat messages
+     * @param messages Array of messages to send
+     * @param onPartialResponse Callback to receive each part of streaming response
+     * @param onCompleteResponse Callback to execute when response is complete
      */
-    async initializeMCPSchemas() {
-      if (this.mcpSchemasInitialized || this.mcpServers.length === 0) {
-        return;
-      }
-      try {
-        const timeoutPromise = new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("MCP schema fetch timeout")), 5e3)
-        );
-        const schemasPromise = MCPSchemaFetcher.fetchAllToolSchemas(
-          this.mcpServers
-        );
-        this.mcpToolSchemas = await Promise.race([
-          schemasPromise,
-          timeoutPromise
-        ]);
-        this.mcpSchemasInitialized = true;
-      } catch (error) {
-        console.warn("Failed to initialize MCP schemas, using fallback:", error);
-        this.mcpToolSchemas = this.mcpServers.map((server) => ({
-          name: `mcp_${server.name}_search`,
-          description: `Search using ${server.name} MCP server (fallback)`,
-          parameters: {
-            type: "object",
-            properties: {
-              query: {
-                type: "string",
-                description: "Search query"
-              }
-            },
-            required: ["query"]
+    async processChat(messages, onPartialResponse, onCompleteResponse) {
+      await processChatWithOptionalTools({
+        hasTools: this.tools.length > 0,
+        runWithoutTools: async () => {
+          const res = await this.callOpenAI(messages, this.model, true);
+          const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
+          try {
+            if (isResponsesAPI) {
+              const result = await parseOpenAIResponsesStream(
+                res,
+                onPartialResponse
+              );
+              return StreamTextAccumulator.getFullText(result.blocks);
+            }
+            return this.handleStream(res, onPartialResponse);
+          } catch (error) {
+            console.error("[processChat] Error in streaming/completion:", error);
+            throw error;
           }
-        }));
-        this.mcpSchemasInitialized = true;
-      }
+        },
+        runWithTools: () => this.chatOnce(messages, true, onPartialResponse),
+        onCompleteResponse,
+        toolErrorMessage: "processChat received tool_calls. ChatProcessor must use chatOnce() loop when tools are enabled."
+      });
     }
     /**
-     * Process chat messages
-     * @param messages Array of messages to send
+     * Process chat messages with images
+     * @param messages Array of messages to send (including images)
      * @param onPartialResponse Callback to receive each part of streaming response
      * @param onCompleteResponse Callback to execute when response is complete
+     * @throws Error if the selected model doesn't support vision
      */
-    async processChat(messages, onPartialResponse, onCompleteResponse) {
+    async processVisionChat(messages, onPartialResponse, onCompleteResponse) {
       try {
         await processChatWithOptionalTools({
-          hasTools: this.tools.length > 0 || this.mcpServers.length > 0,
+          hasTools: this.tools.length > 0,
           runWithoutTools: async () => {
-            const res = await this.callGemini(messages, this.model, true);
-            const { blocks } = await this.parseStream(
-              res,
-              onPartialResponse,
-              this.model
-            );
-            return StreamTextAccumulator.getFullText(blocks);
+            const res = await this.callOpenAI(messages, this.visionModel, true);
+            const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
+            try {
+              if (isResponsesAPI) {
+                const result = await parseOpenAIResponsesStream(
+                  res,
+                  onPartialResponse
+                );
+                return StreamTextAccumulator.getFullText(result.blocks);
+              }
+              return this.handleStream(res, onPartialResponse);
+            } catch (streamError) {
+              console.error(
+                "[processVisionChat] Error in streaming/completion:",
+                streamError
+              );
+              throw streamError;
+            }
           },
-          runWithTools: () => this.chatOnce(messages, true, onPartialResponse),
+          runWithTools: () => this.visionChatOnce(messages, true, onPartialResponse),
           onCompleteResponse,
-          toolErrorMessage: "Received functionCall. Use chatOnce() loop when tools are enabled."
+          toolErrorMessage: "processVisionChat received tool_calls. ChatProcessor must use visionChatOnce() loop when tools are enabled."
         });
-      } catch (err) {
-        console.error("Error in processChat:", err);
-        throw err;
+      } catch (error) {
+        console.error("Error in processVisionChat:", error);
+        throw error;
       }
     }
-    async processVisionChat(messages, onPartialResponse, onCompleteResponse) {
-      try {
-        await processChatWithOptionalTools({
-          hasTools: this.tools.length > 0 || this.mcpServers.length > 0,
-          runWithoutTools: async () => {
-            const res = await this.callGemini(messages, this.visionModel, true);
-            const { blocks } = await this.parseStream(
-              res,
-              onPartialResponse,
-              this.visionModel
-            );
-            return StreamTextAccumulator.getFullText(blocks);
-          },
-          runWithTools: () => this.visionChatOnce(messages),
-          onToolBlocks: (blocks) => {
-            blocks.filter(
-              (b) => b.type === "text"
-            ).forEach((b) => onPartialResponse(b.text));
-          },
-          onCompleteResponse,
-          toolErrorMessage: "Received functionCall. Use visionChatOnce() loop when tools are enabled."
-        });
-      } catch (err) {
-        console.error("Error in processVisionChat:", err);
-        throw err;
+    /**
+     * Process chat messages with tools (text only)
+     * @param messages Array of messages to send
+     * @param stream Whether to use streaming
+     * @param onPartialResponse Callback for partial responses
+     * @param maxTokens Maximum tokens for response (optional)
+     * @returns Tool chat completion
+     */
+    async chatOnce(messages, stream = true, onPartialResponse = () => {
+    }, maxTokens) {
+      const res = await this.callOpenAI(messages, this.model, stream, maxTokens);
+      return this.parseResponse(res, stream, onPartialResponse);
+    }
+    /**
+     * Process vision chat messages with tools
+     * @param messages Array of messages to send (including images)
+     * @param stream Whether to use streaming
+     * @param onPartialResponse Callback for partial responses
+     * @param maxTokens Maximum tokens for response (optional)
+     * @returns Tool chat completion
+     */
+    async visionChatOnce(messages, stream = false, onPartialResponse = () => {
+    }, maxTokens) {
+      const res = await this.callOpenAI(
+        messages,
+        this.visionModel,
+        stream,
+        maxTokens
+      );
+      return this.parseResponse(res, stream, onPartialResponse);
+    }
+    /**
+     * Parse response based on endpoint type
+     */
+    async parseResponse(res, stream, onPartialResponse) {
+      const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
+      if (isResponsesAPI) {
+        return stream ? parseOpenAIResponsesStream(res, onPartialResponse) : parseOpenAIResponsesOneShot(await res.json());
       }
+      return stream ? this.parseStream(res, onPartialResponse) : this.parseOneShot(await res.json());
     }
-    /* ────────────────────────────────── */
-    /*  OpenAI → Gemini conversion         */
-    /* ────────────────────────────────── */
-    convertMessagesToGeminiFormat(messages) {
-      const gemini = [];
-      let currentRole = null;
-      let currentParts = [];
-      const pushCurrent = () => {
-        if (currentRole && currentParts.length) {
-          gemini.push({ role: currentRole, parts: [...currentParts] });
-          currentParts = [];
-        }
-      };
-      for (const msg of messages) {
-        const role = this.mapRoleToGemini(msg.role);
-        if (msg.tool_calls) {
-          pushCurrent();
-          for (const call of msg.tool_calls) {
-            this.callIdMap.set(call.id, call.function.name);
-            gemini.push({
-              role: "model",
-              parts: [
-                {
-                  functionCall: {
-                    name: call.function.name,
-                    args: JSON.parse(call.function.arguments || "{}")
-                  }
-                }
-              ]
-            });
-          }
-          continue;
-        }
-        if (msg.role === "tool") {
-          pushCurrent();
-          const funcName = msg.name ?? this.callIdMap.get(msg.tool_call_id) ?? "result";
-          gemini.push({
-            role: "user",
-            parts: [
-              {
-                functionResponse: {
-                  name: funcName,
-                  response: this.normalizeToolResult(
-                    this.safeJsonParse(msg.content)
-                  )
-                }
-              }
-            ]
-          });
-          continue;
-        }
-        if (role !== currentRole) pushCurrent();
-        currentRole = role;
-        currentParts.push({ text: msg.content });
+    async callOpenAI(messages, model, stream = false, maxTokens) {
+      const body = this.buildRequestBody(messages, model, stream, maxTokens);
+      const headers = {};
+      const shouldSendAuthorization = this.provider !== "openai-compatible" || this.apiKey.trim() !== "";
+      if (shouldSendAuthorization) {
+        headers.Authorization = `Bearer ${this.apiKey}`;
       }
-      pushCurrent();
-      return gemini;
+      const res = await ChatServiceHttpClient.post(this.endpoint, body, headers);
+      return res;
     }
-    /* ────────────────────────────────── */
-    /*  HTTP call                           */
-    /* ────────────────────────────────── */
-    async callGemini(messages, model, stream = false, maxTokens) {
-      const hasVision = messages.some(
-        (m) => Array.isArray(m.content) && m.content.some(
-          (b) => b?.type === "image_url" || b?.inlineData
-        )
-      );
-      const contents = hasVision ? await this.convertVisionMessagesToGeminiFormat(
-        messages
-      ) : this.convertMessagesToGeminiFormat(messages);
+    /**
+     * Build request body based on the endpoint type
+     */
+    buildRequestBody(messages, model, stream, maxTokens) {
+      const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
+      this.validateMCPCompatibility();
       const body = {
-        contents,
-        generationConfig: {
-          maxOutputTokens: maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength)
-        }
+        model,
+        stream
       };
-      if (this.isGemma4Model(model)) {
-        body.generationConfig.thinkingConfig = {
-          includeThoughts: false,
-          thinkingLevel: "minimal"
-        };
-      }
-      const allToolDeclarations = [];
-      if (this.tools.length > 0) {
-        allToolDeclarations.push(
-          ...this.tools.map((t) => ({
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters
-          }))
-        );
-      }
-      if (this.mcpServers.length > 0) {
-        try {
-          await this.initializeMCPSchemas();
-          allToolDeclarations.push(
-            ...this.mcpToolSchemas.map((t) => ({
-              name: t.name,
-              description: t.description,
-              parameters: t.parameters
-            }))
-          );
-        } catch (error) {
-          console.warn("MCP initialization failed, skipping MCP tools:", error);
+      const tokenLimit = this.resolveTokenLimit(model, maxTokens);
+      if (isResponsesAPI) {
+        if (tokenLimit !== void 0) {
+          body.max_output_tokens = tokenLimit;
         }
-      }
-      if (allToolDeclarations.length > 0) {
-        body.tools = [
-          {
-            functionDeclarations: allToolDeclarations
+      } else {
+        if (tokenLimit !== void 0) {
+          if (this.usesCompatibleChatCompletions()) {
+            body.max_tokens = tokenLimit;
+          } else {
+            body.max_completion_tokens = tokenLimit;
           }
-        ];
-        body.toolConfig = { functionCallingConfig: { mode: "AUTO" } };
+        }
       }
-      const fetchOnce = async (ver, payload) => {
-        const fn = stream ? "streamGenerateContent" : "generateContent";
-        const alt = stream ? "?alt=sse" : "";
-        const url = `${ENDPOINT_GEMINI_API}/${ver}/models/${model}:${fn}${alt}${alt ? "&" : "?"}key=${this.apiKey}`;
-        return ChatServiceHttpClient.post(url, payload);
-      };
-      const isLite = /flash[-_]lite/.test(model);
-      const isGemma4 = this.isGemma4Model(model);
-      const isGemini25 = /gemini-2\.5/.test(model);
-      const isGemini3Preview = /^gemini-3(?:\.[0-9]+)?-.*preview/.test(model);
-      const requiresV1beta = isLite || isGemma4 || isGemini25 || isGemini3Preview;
-      const firstVer = requiresV1beta ? "v1beta" : "v1";
-      const tryApi = async () => {
-        try {
-          const payload = firstVer === "v1" ? body : this.adaptKeysForApi(body);
-          return await fetchOnce(firstVer, payload);
-        } catch (e) {
-          const looksLikeVersionMismatch = /Unknown name|Cannot find field|404/.test(e?.message || "") || e?.status === 404;
-          if (!requiresV1beta && looksLikeVersionMismatch) {
-            return await fetchOnce("v1beta", this.adaptKeysForApi(body));
+      if (isResponsesAPI) {
+        body.input = this.cleanMessagesForResponsesAPI(messages);
+      } else {
+        body.messages = this.provider === "mistral" ? this.cleanMessagesForMistralChatCompletions(messages) : messages;
+      }
+      if (isGPT5Model(model)) {
+        if (isResponsesAPI) {
+          if (this.reasoning_effort) {
+            body.reasoning = {
+              ...body.reasoning,
+              effort: this.reasoning_effort
+            };
+            if (this.enableReasoningSummary) {
+              body.reasoning.summary = "auto";
+            }
+          }
+          if (this.verbosity) {
+            body.text = {
+              ...body.text,
+              format: { type: "text" },
+              verbosity: this.verbosity
+            };
+          }
+        } else {
+          if (this.reasoning_effort) {
+            body.reasoning_effort = this.reasoning_effort;
+          }
+          if (this.verbosity) {
+            body.verbosity = this.verbosity;
           }
-          throw e;
         }
-      };
-      try {
-        const res = await tryApi();
-        return res;
-      } catch (error) {
-        if (error.body) {
-          console.error("Gemini API Error Details:", error.body);
-          console.error("Request Body:", JSON.stringify(body, null, 2));
+      }
+      if (this.provider === "mistral" && isMistralReasoningEffortModel(model) && this.reasoning_effort && isMistralReasoningEffort(this.reasoning_effort)) {
+        body.reasoning_effort = this.reasoning_effort;
+      }
+      const tools = this.buildToolsDefinition();
+      if (tools.length > 0) {
+        body.tools = tools;
+        if (!isResponsesAPI) {
+          body.tool_choice = "auto";
         }
-        throw error;
       }
+      return body;
     }
-    /**
-     * Convert AITuber OnAir vision messages to Gemini format
-     * @param messages Array of vision messages
-     * @returns Gemini formatted vision messages
+    resolveTokenLimit(model, maxTokens) {
+      if (maxTokens !== void 0) {
+        return maxTokens;
+      }
+      const baseTokenLimit = this.usesCompatibleChatCompletions() ? this.responseLength !== void 0 ? getMaxTokensForResponseLength(this.responseLength) : void 0 : getMaxTokensForResponseLength(this.responseLength);
+      if (this.provider !== "openai" || !isGPT5Model(model) || this.responseLength === void 0) {
+        return baseTokenLimit;
+      }
+      const effectiveReasoningEffort = this.reasoning_effort ?? getDefaultReasoningEffortForGPT5Model(model);
+      return Math.max(
+        baseTokenLimit ?? 0,
+        GPT5_RESPONSE_LENGTH_MIN_TOKENS[this.responseLength],
+        GPT5_REASONING_MIN_TOKENS[effectiveReasoningEffort]
+      );
+    }
+    /**
+     * Validate MCP servers compatibility with the current endpoint
      */
-    async convertVisionMessagesToGeminiFormat(messages) {
-      const geminiMessages = [];
-      let currentRole = null;
-      let currentParts = [];
-      for (const msg of messages) {
-        const role = this.mapRoleToGemini(msg.role);
-        if (msg.tool_calls) {
-          for (const call of msg.tool_calls) {
-            geminiMessages.push({
-              role: "model",
-              parts: [
-                {
-                  functionCall: {
-                    name: call.function.name,
-                    args: JSON.parse(call.function.arguments || "{}")
-                  }
-                }
-              ]
-            });
-          }
-          continue;
-        }
-        if (msg.role === "tool") {
-          const funcName = msg.name ?? this.callIdMap.get(msg.tool_call_id) ?? "result";
-          geminiMessages.push({
-            role: "user",
-            parts: [
-              {
-                functionResponse: {
-                  name: funcName,
-                  response: this.normalizeToolResult(
-                    this.safeJsonParse(msg.content)
-                  )
-                }
-              }
-            ]
-          });
-          continue;
-        }
-        if (role !== currentRole && currentParts.length > 0) {
-          geminiMessages.push({
-            role: currentRole,
-            parts: [...currentParts]
-          });
-          currentParts = [];
-        }
-        currentRole = role;
+    validateMCPCompatibility() {
+      if (this.mcpServers.length > 0 && this.endpoint === ENDPOINT_OPENAI_CHAT_COMPLETIONS_API) {
+        throw new Error(
+          `MCP servers are not supported with Chat Completions API. Current endpoint: ${this.endpoint}. Please use OpenAI Responses API endpoint: ${ENDPOINT_OPENAI_RESPONSES_API}. MCP tools are only available in the Responses API endpoint.`
+        );
+      }
+    }
+    /**
+     * Clean messages for Responses API (remove timestamp and other extra properties)
+     */
+    cleanMessagesForResponsesAPI(messages) {
+      return messages.map((msg) => {
+        const role = msg.role === "tool" ? "user" : msg.role;
+        const cleanMsg = {
+          role
+        };
         if (typeof msg.content === "string") {
-          currentParts.push({ text: msg.content });
+          cleanMsg.content = msg.content;
         } else if (Array.isArray(msg.content)) {
-          for (const block of msg.content) {
+          cleanMsg.content = msg.content.map((block) => {
             if (block.type === "text") {
-              currentParts.push({ text: block.text });
+              return {
+                type: "input_text",
+                text: block.text
+              };
             } else if (block.type === "image_url") {
-              try {
-                const imageResponse = await ChatServiceHttpClient.get(
-                  block.image_url.url
-                );
-                const imageBlob = await imageResponse.blob();
-                const base64Data = await this.blobToBase64(imageBlob);
-                currentParts.push({
-                  inlineData: {
-                    mimeType: imageBlob.type || "image/jpeg",
-                    data: base64Data.split(",")[1]
-                    // Remove the "data:image/jpeg;base64," prefix
-                  }
-                });
-              } catch (error) {
-                console.error("Error processing image:", error);
-                throw new Error(`Failed to process image: ${error.message}`);
-              }
+              return {
+                type: "input_image",
+                image_url: block.image_url.url
+                // Extract the URL string directly
+              };
             }
-          }
+            return block;
+          });
+        } else {
+          cleanMsg.content = msg.content;
         }
-      }
-      if (currentRole && currentParts.length > 0) {
-        geminiMessages.push({
-          role: currentRole,
-          parts: [...currentParts]
-        });
-      }
-      return geminiMessages;
+        return cleanMsg;
+      });
     }
-    /**
-     * Convert Blob to Base64 string
-     * @param blob Image blob
-     * @returns Promise with base64 encoded string
-     */
-    blobToBase64(blob) {
-      return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onloadend = () => resolve(reader.result);
-        reader.onerror = reject;
-        reader.readAsDataURL(blob);
+    cleanMessagesForMistralChatCompletions(messages) {
+      return messages.map((msg) => {
+        if (!Array.isArray(msg.content)) {
+          return msg;
+        }
+        return {
+          ...msg,
+          content: msg.content.map((block) => {
+            if (block.type === "image_url" && typeof block.image_url === "object" && typeof block.image_url?.url === "string") {
+              return {
+                type: "image_url",
+                image_url: block.image_url.url
+              };
+            }
+            return block;
+          })
+        };
       });
     }
     /**
-     * Map AITuber OnAir roles to Gemini roles
-     * @param role AITuber OnAir role
-     * @returns Gemini role
+     * Build tools definition based on the endpoint type
      */
-    mapRoleToGemini(role) {
-      switch (role) {
-        case "system":
-          return "model";
-        // Gemini uses 'model' for system messages
-        case "user":
-          return "user";
-        case "assistant":
-          return "model";
-        default:
-          return "user";
+    buildToolsDefinition() {
+      const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
+      const toolDefs = [];
+      if (this.tools.length > 0) {
+        toolDefs.push(
+          ...buildOpenAICompatibleTools(
+            this.tools,
+            isResponsesAPI ? "responses" : "chat-completions"
+          )
+        );
+      }
+      if (this.mcpServers.length > 0 && isResponsesAPI) {
+        toolDefs.push(...this.buildMCPToolsDefinition());
       }
+      return toolDefs;
     }
-    /* ────────────────────────────────────────────────────────── */
-    /*  Convert NDJSON stream to common format             */
-    /* ────────────────────────────────────────────────────────── */
-    async parseStream(res, onPartial, model) {
-      const reader = res.body.getReader();
-      const dec = new TextDecoder();
-      const textBlocks = [];
-      const toolBlocks = [];
-      let buf = "";
-      const flush = (payload) => {
-        if (!payload || payload === "[DONE]") return;
-        let obj;
-        try {
-          obj = JSON.parse(payload);
-        } catch {
-          return;
+    /**
+     * Build MCP tools definition for Responses API
+     */
+    buildMCPToolsDefinition() {
+      return this.mcpServers.map((server) => {
+        const mcpDef = {
+          type: "mcp",
+          // Using 'mcp' as indicated by the error message
+          server_label: server.name,
+          // Use server_label as required by API
+          server_url: server.url
+          // Use server_url instead of url
+        };
+        if (server.require_approval) {
+          mcpDef.require_approval = server.require_approval;
         }
-        for (const cand of obj.candidates ?? []) {
-          for (const part of cand.content?.parts ?? []) {
-            if (this.shouldExposeTextPart(part, model)) {
-              onPartial(part.text);
-              StreamTextAccumulator.addTextBlock(textBlocks, part.text);
-            }
-            if (part.functionCall) {
-              toolBlocks.push({
-                type: "tool_use",
-                id: this.genUUID(),
-                name: part.functionCall.name,
-                input: part.functionCall.args ?? {}
-              });
-            }
-            if (part.functionResponse) {
-              toolBlocks.push({
-                type: "tool_result",
-                tool_use_id: part.functionResponse.name,
-                content: JSON.stringify(part.functionResponse.response)
-              });
-            }
-          }
+        if (server.tool_configuration?.allowed_tools) {
+          mcpDef.allowed_tools = server.tool_configuration.allowed_tools;
         }
-      };
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buf += dec.decode(value, { stream: true });
-        let nl;
-        while ((nl = buf.indexOf("\n")) !== -1) {
-          let line = buf.slice(0, nl);
-          buf = buf.slice(nl + 1);
-          if (line.endsWith("\r")) line = line.slice(0, -1);
-          if (!line.trim()) {
-            flush("");
-            continue;
-          }
-          if (line.startsWith("data:")) line = line.slice(5).trim();
-          if (!line) continue;
-          flush(line);
+        if (server.authorization_token) {
+          mcpDef.headers = {
+            Authorization: `Bearer ${server.authorization_token}`
+          };
         }
-      }
-      if (buf) flush(buf);
-      const blocks = [...textBlocks, ...toolBlocks];
-      return {
-        blocks,
-        stop_reason: toolBlocks.some((b) => b.type === "tool_use") ? "tool_use" : "end"
-      };
+        return mcpDef;
+      });
     }
-    /* ────────────────────────────────────────────────────────── */
-    /*  Convert JSON of non-stream (= generateContent)        */
-    /* ────────────────────────────────────────────────────────── */
-    parseOneShot(data, model) {
-      const textBlocks = [];
-      const toolBlocks = [];
-      for (const cand of data.candidates ?? []) {
-        for (const part of cand.content?.parts ?? []) {
-          if (this.shouldExposeTextPart(part, model)) {
-            textBlocks.push({ type: "text", text: part.text });
-          }
-          if (part.functionCall) {
-            toolBlocks.push({
-              type: "tool_use",
-              id: this.genUUID(),
-              name: part.functionCall.name,
-              input: part.functionCall.args ?? {}
-            });
-          }
-          if (part.functionResponse) {
-            toolBlocks.push({
-              type: "tool_result",
-              tool_use_id: part.functionResponse.name,
-              content: JSON.stringify(part.functionResponse.response)
-            });
-          }
-        }
-      }
-      const blocks = [...textBlocks, ...toolBlocks];
-      return {
-        blocks,
-        stop_reason: toolBlocks.some((b) => b.type === "tool_use") ? "tool_use" : "end"
-      };
+    async handleStream(res, onPartial) {
+      return parseOpenAICompatibleTextStream(res, onPartial);
     }
-    /* ────────────────────────────────────────────────────────── */
-    /*  chatOnce (text)                                       */
-    /* ────────────────────────────────────────────────────────── */
-    async chatOnce(messages, stream = true, onPartialResponse = () => {
-    }, maxTokens) {
-      const res = await this.callGemini(messages, this.model, stream, maxTokens);
-      return stream ? this.parseStream(res, onPartialResponse, this.model) : this.parseOneShot(await res.json(), this.model);
+    async parseStream(res, onPartial) {
+      return parseOpenAICompatibleToolStream(res, onPartial, {
+        appendTextBlock: StreamTextAccumulator.addTextBlock
+      });
     }
-    /* ────────────────────────────────────────────────────────── */
-    /*  visionChatOnce (images)                               */
-    /* ────────────────────────────────────────────────────────── */
-    async visionChatOnce(messages, stream = false, onPartialResponse = () => {
-    }, maxTokens) {
-      const res = await this.callGemini(
-        messages,
-        this.visionModel,
-        stream,
-        maxTokens
-      );
-      return stream ? this.parseStream(res, onPartialResponse, this.visionModel) : this.parseOneShot(await res.json(), this.visionModel);
+    parseOneShot(data) {
+      return parseOpenAICompatibleOneShot(data);
     }
-    /* ────────────────────────────────────────────────────────── */
-    /*  UUID helper                                           */
-    /* ────────────────────────────────────────────────────────── */
-    genUUID() {
-      return typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-        const r = Math.random() * 16 | 0;
-        const v = c === "x" ? r : r & 3 | 8;
-        return v.toString(16);
-      });
+    usesCompatibleChatCompletions() {
+      return OPENAI_COMPATIBLE_CHAT_COMPLETIONS_PROVIDERS.has(this.provider);
     }
   };
 
-  // src/services/providers/gemini/GeminiChatServiceProvider.ts
-  var GeminiChatServiceProvider = class {
-    /**
-     * Create a chat service instance
-     * @param options Service options
-     * @returns GeminiChatService instance
-     */
+  // src/services/providers/deepseek/DeepSeekChatService.ts
+  var DeepSeekChatService = class extends OpenAIChatService {
+    constructor(apiKey, model = MODEL_DEEPSEEK_V4_FLASH, visionModel = model, tools, endpoint = ENDPOINT_DEEPSEEK_CHAT_COMPLETIONS_API, responseLength) {
+      super(
+        apiKey,
+        model,
+        visionModel,
+        tools,
+        endpoint,
+        [],
+        responseLength,
+        void 0,
+        void 0,
+        false,
+        "deepseek",
+        false
+      );
+    }
+  };
+
+  // src/services/providers/deepseek/DeepSeekChatServiceProvider.ts
+  var DeepSeekChatServiceProvider = class {
     createChatService(options) {
-      const visionModel = resolveVisionModel({
-        model: options.model,
-        visionModel: options.visionModel,
-        defaultModel: this.getDefaultModel(),
-        defaultVisionModel: this.getDefaultModel(),
-        supportsVisionForModel: (model) => this.supportsVisionForModel(model),
-        validate: "resolved"
-      });
-      return new GeminiChatService(
+      this.validateRequiredOptions(options);
+      const model = options.model || this.getDefaultModel();
+      const tools = options.tools;
+      return new DeepSeekChatService(
         options.apiKey,
-        options.model || this.getDefaultModel(),
-        visionModel,
-        options.tools || [],
-        options.mcpServers || [],
+        model,
+        options.visionModel ?? model,
+        tools,
+        this.resolveEndpoint(options),
         options.responseLength
       );
     }
-    /**
-     * Get the provider name
-     * @returns Provider name ('gemini')
-     */
     getProviderName() {
-      return "gemini";
+      return "deepseek";
     }
-    /**
-     * Get the list of supported models
-     * @returns Array of supported model names
-     */
     getSupportedModels() {
-      return [
-        MODEL_GEMMA_4_31B_IT,
-        MODEL_GEMMA_4_26B_A4B_IT,
-        MODEL_GEMINI_3_1_PRO_PREVIEW,
-        MODEL_GEMINI_3_1_FLASH_LITE_PREVIEW,
-        MODEL_GEMINI_3_PRO_PREVIEW,
-        MODEL_GEMINI_3_FLASH_PREVIEW,
-        MODEL_GEMINI_2_5_PRO,
-        MODEL_GEMINI_2_5_FLASH,
-        MODEL_GEMINI_2_5_FLASH_LITE,
-        MODEL_GEMINI_2_5_FLASH_LITE_PREVIEW_06_17,
-        MODEL_GEMINI_2_0_FLASH,
-        MODEL_GEMINI_2_0_FLASH_LITE
-      ];
+      return [...DEEPSEEK_SUPPORTED_MODELS];
     }
-    /**
-     * Get the default model
-     * @returns Default model name
-     */
     getDefaultModel() {
-      return MODEL_GEMINI_2_0_FLASH_LITE;
+      return MODEL_DEEPSEEK_V4_FLASH;
     }
-    /**
-     * Check if this provider supports vision (image processing)
-     * @returns Vision support status (true)
-     */
     supportsVision() {
-      return this.getVisionSupportLevel() !== "unsupported";
+      return false;
     }
     getVisionSupportLevel() {
-      return "supported";
-    }
-    /**
-     * Check if a specific model supports vision capabilities
-     * @param model The model name to check
-     * @returns True if the model supports vision, false otherwise
-     */
-    supportsVisionForModel(model) {
-      return GEMINI_VISION_SUPPORTED_MODELS.includes(model);
-    }
-    getVisionSupportLevelForModel(model) {
-      return this.supportsVisionForModel(model) ? "supported" : "unsupported";
-    }
-  };
-
-  // src/services/providers/geminiNano/GeminiNanoChatService.ts
-  function getLanguageModelAPI() {
-    if (typeof globalThis !== "undefined" && "LanguageModel" in globalThis) {
-      return globalThis.LanguageModel;
-    }
-    return void 0;
-  }
-  var GeminiNanoChatService = class {
-    constructor(options = {}) {
-      this.provider = "gemini-nano";
-      this.expectedInputLanguages = options.expectedInputLanguages ?? ["ja"];
-      this.expectedOutputLanguages = options.expectedOutputLanguages ?? ["ja"];
-      this._responseLength = options.responseLength;
-    }
-    getModel() {
-      return MODEL_GEMINI_NANO;
-    }
-    getVisionModel() {
-      return MODEL_GEMINI_NANO;
-    }
-    /**
-     * Process chat messages using Gemini Nano.
-     * Non-streaming: calls onPartialResponse once with the full response,
-     * then calls onCompleteResponse.
-     */
-    async processChat(messages, onPartialResponse, onCompleteResponse) {
-      const response = await this.generateResponse(messages);
-      onPartialResponse(response);
-      await onCompleteResponse(response);
-    }
-    async processVisionChat(_messages, _onPartialResponse, _onCompleteResponse) {
-      throw new Error("Gemini Nano does not support vision capabilities.");
+      return "unsupported";
     }
-    async chatOnce(messages, _stream = false, onPartialResponse = () => {
-    }, _maxTokens) {
-      const response = await this.generateResponse(messages);
-      onPartialResponse(response);
-      return {
-        blocks: [{ type: "text", text: response }],
-        stop_reason: "end"
-      };
+    supportsVisionForModel(_model) {
+      return false;
     }
-    async visionChatOnce(_messages, _stream = false, _onPartialResponse = () => {
-    }, _maxTokens) {
-      throw new Error("Gemini Nano does not support vision capabilities.");
+    getVisionSupportLevelForModel(_model) {
+      return "unsupported";
     }
-    /**
-     * Core logic: extract system prompt, manage session, call prompt().
-     */
-    async generateResponse(messages) {
-      const api = getLanguageModelAPI();
-      if (!api) {
-        throw new Error(
-          "Gemini Nano is not available in this environment. Chrome 138+ with Prompt API enabled is required."
-        );
-      }
-      const availability = await api.availability();
-      if (availability !== "available" && availability !== "downloadable") {
-        throw new Error(
-          `Gemini Nano Prompt API is not ready in this environment. LanguageModel.availability() returned "${availability}". Expected "available" or "downloadable".`
-        );
+    validateRequiredOptions(options) {
+      if (!options.apiKey?.trim()) {
+        throw new Error("deepseek provider requires apiKey.");
       }
-      const systemMessages = messages.filter((m) => m.role === "system");
-      const systemPrompt = systemMessages.map((m) => m.content).join("\n");
-      const conversationMessages = messages.filter((m) => m.role !== "system").slice(-GEMINI_NANO_MAX_CONTEXT_MESSAGES);
-      const lastUserMessage = [...conversationMessages].reverse().find((m) => m.role === "user");
-      if (!lastUserMessage) {
-        throw new Error("No user message found in the provided messages.");
+    }
+    resolveEndpoint(options) {
+      if (options.endpoint) {
+        return this.normalizeUrl(options.endpoint);
       }
-      const session = await this.createSession(
-        api,
-        systemPrompt,
-        conversationMessages
-      );
-      try {
-        return await session.prompt(lastUserMessage.content);
-      } finally {
-        try {
-          session.destroy();
-        } catch {
+      if (options.baseUrl) {
+        const baseUrl = this.normalizeUrl(options.baseUrl);
+        if (baseUrl.endsWith("/chat/completions")) {
+          return baseUrl;
         }
+        return `${baseUrl}/chat/completions`;
       }
+      return ENDPOINT_DEEPSEEK_CHAT_COMPLETIONS_API;
     }
+    normalizeUrl(value) {
+      return value.trim().replace(/\/+$/, "");
+    }
+  };
+
+  // src/utils/mcpSchemaFetcher.ts
+  var MCPSchemaFetcher = class {
     /**
-     * Create a new LanguageModel session with system prompt and context history.
-     * Context history (excluding the last user message) is embedded in the system prompt.
+     * Fetch tool schemas from MCP server
+     * @param serverConfig MCP server configuration
+     * @returns Array of tool definitions
      */
-    async createSession(api, systemPrompt, contextHistory) {
-      let prompt = this.buildSystemPrompt(systemPrompt);
-      const historyMessages = contextHistory.slice(0, -1);
-      if (historyMessages.length > 0) {
-        const history = historyMessages.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n");
-        prompt += "\n\nThe following is the prior conversation history. Use it as context for your response:\n" + history;
-      }
-      return api.create({
-        systemPrompt: prompt,
-        expectedInputs: [
-          { type: "text", languages: this.expectedInputLanguages }
-        ],
-        expectedOutputs: [
-          { type: "text", languages: this.expectedOutputLanguages }
-        ]
-      });
-    }
-    buildSystemPrompt(systemPrompt) {
-      const promptParts = [];
-      if (systemPrompt) {
-        promptParts.push(systemPrompt);
-      }
-      const lengthInstruction = this.getResponseLengthInstruction();
-      if (lengthInstruction) {
-        promptParts.push(lengthInstruction);
+    static async fetchToolSchemas(serverConfig) {
+      try {
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (serverConfig.authorization_token) {
+          headers["Authorization"] = `Bearer ${serverConfig.authorization_token}`;
+        }
+        const response = await ChatServiceHttpClient.post(
+          `${serverConfig.url}/tools`,
+          {},
+          headers
+        );
+        const toolsData = await response.json();
+        if (Array.isArray(toolsData.tools)) {
+          return toolsData.tools.map((tool) => ({
+            name: `mcp_${serverConfig.name}_${tool.name}`,
+            description: tool.description || `Tool from ${serverConfig.name} MCP server`,
+            parameters: tool.inputSchema || {
+              type: "object",
+              properties: {},
+              required: []
+            }
+          }));
+        }
+        return [
+          {
+            name: `mcp_${serverConfig.name}_search`,
+            description: `Search using ${serverConfig.name} MCP server`,
+            parameters: {
+              type: "object",
+              properties: {
+                query: {
+                  type: "string",
+                  description: "Search query"
+                }
+              },
+              required: ["query"]
+            }
+          }
+        ];
+      } catch (error) {
+        console.warn(
+          `Failed to fetch MCP schemas from ${serverConfig.name}:`,
+          error
+        );
+        return [
+          {
+            name: `mcp_${serverConfig.name}_search`,
+            description: `Search using ${serverConfig.name} MCP server (schema fetch failed)`,
+            parameters: {
+              type: "object",
+              properties: {
+                query: {
+                  type: "string",
+                  description: "Search query"
+                }
+              },
+              required: ["query"]
+            }
+          }
+        ];
       }
-      return promptParts.join("\n\n");
     }
-    getResponseLengthInstruction() {
-      if (!this._responseLength) {
-        return void 0;
-      }
-      const maxTokens = MAX_TOKENS_BY_LENGTH[this._responseLength];
-      if (!maxTokens) {
-        return void 0;
+    /**
+     * Fetch all tool schemas from multiple MCP servers
+     * @param mcpServers Array of MCP server configurations
+     * @returns Array of all tool definitions
+     */
+    static async fetchAllToolSchemas(mcpServers) {
+      const allSchemas = [];
+      for (const server of mcpServers) {
+        try {
+          const schemas = await this.fetchToolSchemas(server);
+          allSchemas.push(...schemas);
+        } catch (error) {
+          console.error(`Failed to fetch schemas from ${server.name}:`, error);
+        }
       }
-      return `Please keep your response concise, within approximately ${maxTokens} tokens.`;
-    }
-  };
-
-  // src/services/providers/geminiNano/GeminiNanoChatServiceProvider.ts
-  var GeminiNanoChatServiceProvider = class {
-    createChatService(options) {
-      return new GeminiNanoChatService({
-        expectedInputLanguages: options.expectedInputLanguages,
-        expectedOutputLanguages: options.expectedOutputLanguages,
-        responseLength: options.responseLength
-      });
-    }
-    getProviderName() {
-      return "gemini-nano";
-    }
-    getSupportedModels() {
-      return [MODEL_GEMINI_NANO];
-    }
-    getDefaultModel() {
-      return MODEL_GEMINI_NANO;
-    }
-    supportsVision() {
-      return false;
-    }
-    getVisionSupportLevel() {
-      return "unsupported";
+      return allSchemas;
     }
   };
 
-  // src/services/providers/kimi/KimiChatService.ts
-  var KimiChatService = class {
+  // src/services/providers/gemini/GeminiChatService.ts
+  var GeminiChatService = class {
     /**
      * Constructor
-     * @param apiKey Kimi API key
+     * @param apiKey Google API key
      * @param model Name of the model to use
      * @param visionModel Name of the vision model
+     * @param tools Array of tool definitions
+     * @param mcpServers Array of MCP server configurations
      */
-    constructor(apiKey, model = MODEL_KIMI_K2_6, visionModel = MODEL_KIMI_K2_6, tools, endpoint = ENDPOINT_KIMI_CHAT_COMPLETIONS_API, responseLength, responseFormat, thinking) {
+    constructor(apiKey, model = MODEL_GEMINI_3_1_FLASH_LITE, visionModel = MODEL_GEMINI_3_1_FLASH_LITE, tools = [], mcpServers = [], responseLength) {
       /** Provider name */
-      this.provider = "kimi";
+      this.provider = "gemini";
+      this.mcpToolSchemas = [];
+      this.mcpSchemasInitialized = false;
+      /** id(OpenAI) → name(Gemini) mapping */
+      this.callIdMap = /* @__PURE__ */ new Map();
       this.apiKey = apiKey;
       this.model = model;
-      this.tools = tools || [];
-      this.endpoint = endpoint;
       this.responseLength = responseLength;
-      this.responseFormat = responseFormat;
-      this.thinking = thinking ?? { type: "enabled" };
+      if (!GEMINI_VISION_SUPPORTED_MODELS.includes(visionModel)) {
+        throw new Error(
+          `Model ${visionModel} does not support vision capabilities.`
+        );
+      }
       this.visionModel = visionModel;
+      this.tools = tools;
+      this.mcpServers = mcpServers;
+    }
+    /* ────────────────────────────────── */
+    /*  Utilities                           */
+    /* ────────────────────────────────── */
+    safeJsonParse(str) {
+      try {
+        return JSON.parse(str);
+      } catch {
+        return str;
+      }
+    }
+    normalizeToolResult(val) {
+      if (val === null) return { content: null };
+      if (typeof val === "object") return val;
+      return { content: val };
+    }
+    isGemma4Model(model) {
+      return /^gemma-4-/.test(model);
+    }
+    shouldExposeTextPart(part, model) {
+      if (!part.text) return false;
+      if (this.isGemma4Model(model) && part.thought === true) {
+        return false;
+      }
+      return true;
+    }
+    /**
+     * camelCase → snake_case conversion (v1beta)
+     */
+    adaptKeysForApi(obj) {
+      const map = {
+        toolConfig: "tool_config",
+        functionCallingConfig: "function_calling_config",
+        functionDeclarations: "function_declarations",
+        functionCall: "function_call",
+        functionResponse: "function_response"
+      };
+      if (Array.isArray(obj)) return obj.map((v) => this.adaptKeysForApi(v));
+      if (obj && typeof obj === "object") {
+        return Object.fromEntries(
+          Object.entries(obj).map(([k, v]) => [
+            map[k] ?? k,
+            this.adaptKeysForApi(v)
+          ])
+        );
+      }
+      return obj;
     }
     /**
      * Get the current model name
+     * @returns Model name
      */
     getModel() {
       return this.model;
     }
     /**
      * Get the current vision model name
+     * @returns Vision model name
      */
     getVisionModel() {
       return this.visionModel;
     }
     /**
-     * Process chat messages
+     * Get configured MCP servers
+     * @returns Array of MCP server configurations
      */
-    async processChat(messages, onPartialResponse, onCompleteResponse) {
-      await processChatWithOptionalTools({
-        hasTools: this.tools.length > 0,
-        runWithoutTools: async () => {
-          const res = await this.callKimi(messages, this.model, true);
-          return this.handleStream(res, onPartialResponse);
-        },
-        runWithTools: () => this.chatOnce(messages, true, onPartialResponse),
-        onCompleteResponse,
-        toolErrorMessage: "processChat received tool_calls. ChatProcessor must use chatOnce() loop when tools are enabled."
-      });
+    getMCPServers() {
+      return this.mcpServers;
     }
     /**
-     * Process chat messages with images
+     * Add MCP server configuration
+     * @param serverConfig MCP server configuration
      */
-    async processVisionChat(messages, onPartialResponse, onCompleteResponse) {
-      if (!isKimiVisionModel(this.visionModel)) {
-        throw new Error(
-          `Model ${this.visionModel} does not support vision capabilities.`
-        );
+    addMCPServer(serverConfig) {
+      this.mcpServers.push(serverConfig);
+      this.mcpSchemasInitialized = false;
+    }
+    /**
+     * Remove MCP server by name
+     * @param serverName Name of the server to remove
+     */
+    removeMCPServer(serverName) {
+      this.mcpServers = this.mcpServers.filter(
+        (server) => server.name !== serverName
+      );
+      this.mcpSchemasInitialized = false;
+    }
+    /**
+     * Check if MCP servers are configured
+     * @returns True if MCP servers are configured
+     */
+    hasMCPServers() {
+      return this.mcpServers.length > 0;
+    }
+    /**
+     * Initialize MCP tool schemas by fetching from servers
+     * @private
+     */
+    async initializeMCPSchemas() {
+      if (this.mcpSchemasInitialized || this.mcpServers.length === 0) {
+        return;
+      }
+      try {
+        const timeoutPromise = new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("MCP schema fetch timeout")), 5e3)
+        );
+        const schemasPromise = MCPSchemaFetcher.fetchAllToolSchemas(
+          this.mcpServers
+        );
+        this.mcpToolSchemas = await Promise.race([
+          schemasPromise,
+          timeoutPromise
+        ]);
+        this.mcpSchemasInitialized = true;
+      } catch (error) {
+        console.warn("Failed to initialize MCP schemas, using fallback:", error);
+        this.mcpToolSchemas = this.mcpServers.map((server) => ({
+          name: `mcp_${server.name}_search`,
+          description: `Search using ${server.name} MCP server (fallback)`,
+          parameters: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: "Search query"
+              }
+            },
+            required: ["query"]
+          }
+        }));
+        this.mcpSchemasInitialized = true;
+      }
+    }
+    /**
+     * Process chat messages
+     * @param messages Array of messages to send
+     * @param onPartialResponse Callback to receive each part of streaming response
+     * @param onCompleteResponse Callback to execute when response is complete
+     */
+    async processChat(messages, onPartialResponse, onCompleteResponse) {
+      try {
+        await processChatWithOptionalTools({
+          hasTools: this.tools.length > 0 || this.mcpServers.length > 0,
+          runWithoutTools: async () => {
+            const res = await this.callGemini(messages, this.model, true);
+            const { blocks } = await this.parseStream(
+              res,
+              onPartialResponse,
+              this.model
+            );
+            return StreamTextAccumulator.getFullText(blocks);
+          },
+          runWithTools: () => this.chatOnce(messages, true, onPartialResponse),
+          onCompleteResponse,
+          toolErrorMessage: "Received functionCall. Use chatOnce() loop when tools are enabled."
+        });
+      } catch (err) {
+        console.error("Error in processChat:", err);
+        throw err;
+      }
+    }
+    async processVisionChat(messages, onPartialResponse, onCompleteResponse) {
+      try {
+        await processChatWithOptionalTools({
+          hasTools: this.tools.length > 0 || this.mcpServers.length > 0,
+          runWithoutTools: async () => {
+            const res = await this.callGemini(messages, this.visionModel, true);
+            const { blocks } = await this.parseStream(
+              res,
+              onPartialResponse,
+              this.visionModel
+            );
+            return StreamTextAccumulator.getFullText(blocks);
+          },
+          runWithTools: () => this.visionChatOnce(messages),
+          onToolBlocks: (blocks) => {
+            blocks.filter(
+              (b) => b.type === "text"
+            ).forEach((b) => onPartialResponse(b.text));
+          },
+          onCompleteResponse,
+          toolErrorMessage: "Received functionCall. Use visionChatOnce() loop when tools are enabled."
+        });
+      } catch (err) {
+        console.error("Error in processVisionChat:", err);
+        throw err;
+      }
+    }
+    /* ────────────────────────────────── */
+    /*  OpenAI → Gemini conversion         */
+    /* ────────────────────────────────── */
+    convertMessagesToGeminiFormat(messages) {
+      const gemini = [];
+      let currentRole = null;
+      let currentParts = [];
+      const pushCurrent = () => {
+        if (currentRole && currentParts.length) {
+          gemini.push({ role: currentRole, parts: [...currentParts] });
+          currentParts = [];
+        }
+      };
+      for (const msg of messages) {
+        const role = this.mapRoleToGemini(msg.role);
+        if (msg.tool_calls) {
+          pushCurrent();
+          for (const call of msg.tool_calls) {
+            this.callIdMap.set(call.id, call.function.name);
+            gemini.push({
+              role: "model",
+              parts: [
+                {
+                  functionCall: {
+                    name: call.function.name,
+                    args: JSON.parse(call.function.arguments || "{}")
+                  }
+                }
+              ]
+            });
+          }
+          continue;
+        }
+        if (msg.role === "tool") {
+          pushCurrent();
+          const funcName = msg.name ?? this.callIdMap.get(msg.tool_call_id) ?? "result";
+          gemini.push({
+            role: "user",
+            parts: [
+              {
+                functionResponse: {
+                  name: funcName,
+                  response: this.normalizeToolResult(
+                    this.safeJsonParse(msg.content)
+                  )
+                }
+              }
+            ]
+          });
+          continue;
+        }
+        if (role !== currentRole) pushCurrent();
+        currentRole = role;
+        currentParts.push({ text: msg.content });
+      }
+      pushCurrent();
+      return gemini;
+    }
+    /* ────────────────────────────────── */
+    /*  HTTP call                           */
+    /* ────────────────────────────────── */
+    async callGemini(messages, model, stream = false, maxTokens) {
+      const hasVision = messages.some(
+        (m) => Array.isArray(m.content) && m.content.some(
+          (b) => b?.type === "image_url" || b?.inlineData
+        )
+      );
+      const contents = hasVision ? await this.convertVisionMessagesToGeminiFormat(
+        messages
+      ) : this.convertMessagesToGeminiFormat(messages);
+      const body = {
+        contents,
+        generationConfig: {
+          maxOutputTokens: maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength)
+        }
+      };
+      if (this.isGemma4Model(model)) {
+        body.generationConfig.thinkingConfig = {
+          includeThoughts: false,
+          thinkingLevel: "minimal"
+        };
+      }
+      const allToolDeclarations = [];
+      if (this.tools.length > 0) {
+        allToolDeclarations.push(
+          ...this.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters
+          }))
+        );
+      }
+      if (this.mcpServers.length > 0) {
+        try {
+          await this.initializeMCPSchemas();
+          allToolDeclarations.push(
+            ...this.mcpToolSchemas.map((t) => ({
+              name: t.name,
+              description: t.description,
+              parameters: t.parameters
+            }))
+          );
+        } catch (error) {
+          console.warn("MCP initialization failed, skipping MCP tools:", error);
+        }
+      }
+      if (allToolDeclarations.length > 0) {
+        body.tools = [
+          {
+            functionDeclarations: allToolDeclarations
+          }
+        ];
+        body.toolConfig = { functionCallingConfig: { mode: "AUTO" } };
+      }
+      const fetchOnce = async (ver, payload) => {
+        const fn = stream ? "streamGenerateContent" : "generateContent";
+        const alt = stream ? "?alt=sse" : "";
+        const url = `${ENDPOINT_GEMINI_API}/${ver}/models/${model}:${fn}${alt}${alt ? "&" : "?"}key=${this.apiKey}`;
+        return ChatServiceHttpClient.post(url, payload);
+      };
+      const isLite = /flash[-_]lite/.test(model);
+      const isGemma4 = this.isGemma4Model(model);
+      const isGemini25 = /gemini-2\.5/.test(model);
+      const isGemini3Preview = /^gemini-3(?:\.[0-9]+)?-.*preview/.test(model);
+      const requiresV1beta = isLite || isGemma4 || isGemini25 || isGemini3Preview;
+      const firstVer = requiresV1beta ? "v1beta" : "v1";
+      const tryApi = async () => {
+        try {
+          const payload = firstVer === "v1" ? body : this.adaptKeysForApi(body);
+          return await fetchOnce(firstVer, payload);
+        } catch (e) {
+          const looksLikeVersionMismatch = /Unknown name|Cannot find field|404/.test(e?.message || "") || e?.status === 404;
+          if (!requiresV1beta && looksLikeVersionMismatch) {
+            return await fetchOnce("v1beta", this.adaptKeysForApi(body));
+          }
+          throw e;
+        }
+      };
+      try {
+        const res = await tryApi();
+        return res;
+      } catch (error) {
+        if (error.body) {
+          console.error("Gemini API Error Details:", error.body);
+          console.error("Request Body:", JSON.stringify(body, null, 2));
+        }
+        throw error;
+      }
+    }
+    /**
+     * Convert AITuber OnAir vision messages to Gemini format
+     * @param messages Array of vision messages
+     * @returns Gemini formatted vision messages
+     */
+    async convertVisionMessagesToGeminiFormat(messages) {
+      const geminiMessages = [];
+      let currentRole = null;
+      let currentParts = [];
+      for (const msg of messages) {
+        const role = this.mapRoleToGemini(msg.role);
+        if (msg.tool_calls) {
+          for (const call of msg.tool_calls) {
+            geminiMessages.push({
+              role: "model",
+              parts: [
+                {
+                  functionCall: {
+                    name: call.function.name,
+                    args: JSON.parse(call.function.arguments || "{}")
+                  }
+                }
+              ]
+            });
+          }
+          continue;
+        }
+        if (msg.role === "tool") {
+          const funcName = msg.name ?? this.callIdMap.get(msg.tool_call_id) ?? "result";
+          geminiMessages.push({
+            role: "user",
+            parts: [
+              {
+                functionResponse: {
+                  name: funcName,
+                  response: this.normalizeToolResult(
+                    this.safeJsonParse(msg.content)
+                  )
+                }
+              }
+            ]
+          });
+          continue;
+        }
+        if (role !== currentRole && currentParts.length > 0) {
+          geminiMessages.push({
+            role: currentRole,
+            parts: [...currentParts]
+          });
+          currentParts = [];
+        }
+        currentRole = role;
+        if (typeof msg.content === "string") {
+          currentParts.push({ text: msg.content });
+        } else if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block.type === "text") {
+              currentParts.push({ text: block.text });
+            } else if (block.type === "image_url") {
+              try {
+                const imageResponse = await ChatServiceHttpClient.get(
+                  block.image_url.url
+                );
+                const imageBlob = await imageResponse.blob();
+                const base64Data = await this.blobToBase64(imageBlob);
+                currentParts.push({
+                  inlineData: {
+                    mimeType: imageBlob.type || "image/jpeg",
+                    data: base64Data.split(",")[1]
+                    // Remove the "data:image/jpeg;base64," prefix
+                  }
+                });
+              } catch (error) {
+                console.error("Error processing image:", error);
+                throw new Error(`Failed to process image: ${error.message}`);
+              }
+            }
+          }
+        }
+      }
+      if (currentRole && currentParts.length > 0) {
+        geminiMessages.push({
+          role: currentRole,
+          parts: [...currentParts]
+        });
+      }
+      return geminiMessages;
+    }
+    /**
+     * Convert Blob to Base64 string
+     * @param blob Image blob
+     * @returns Promise with base64 encoded string
+     */
+    blobToBase64(blob) {
+      return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = () => resolve(reader.result);
+        reader.onerror = reject;
+        reader.readAsDataURL(blob);
+      });
+    }
+    /**
+     * Map AITuber OnAir roles to Gemini roles
+     * @param role AITuber OnAir role
+     * @returns Gemini role
+     */
+    mapRoleToGemini(role) {
+      switch (role) {
+        case "system":
+          return "model";
+        // Gemini uses 'model' for system messages
+        case "user":
+          return "user";
+        case "assistant":
+          return "model";
+        default:
+          return "user";
+      }
+    }
+    /* ────────────────────────────────────────────────────────── */
+    /*  Convert NDJSON stream to common format             */
+    /* ────────────────────────────────────────────────────────── */
+    async parseStream(res, onPartial, model) {
+      const reader = res.body.getReader();
+      const dec = new TextDecoder();
+      const textBlocks = [];
+      const toolBlocks = [];
+      let buf = "";
+      const flush = (payload) => {
+        if (!payload || payload === "[DONE]") return;
+        let obj;
+        try {
+          obj = JSON.parse(payload);
+        } catch {
+          return;
+        }
+        for (const cand of obj.candidates ?? []) {
+          for (const part of cand.content?.parts ?? []) {
+            if (this.shouldExposeTextPart(part, model)) {
+              onPartial(part.text);
+              StreamTextAccumulator.addTextBlock(textBlocks, part.text);
+            }
+            if (part.functionCall) {
+              toolBlocks.push({
+                type: "tool_use",
+                id: this.genUUID(),
+                name: part.functionCall.name,
+                input: part.functionCall.args ?? {}
+              });
+            }
+            if (part.functionResponse) {
+              toolBlocks.push({
+                type: "tool_result",
+                tool_use_id: part.functionResponse.name,
+                content: JSON.stringify(part.functionResponse.response)
+              });
+            }
+          }
+        }
+      };
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += dec.decode(value, { stream: true });
+        let nl;
+        while ((nl = buf.indexOf("\n")) !== -1) {
+          let line = buf.slice(0, nl);
+          buf = buf.slice(nl + 1);
+          if (line.endsWith("\r")) line = line.slice(0, -1);
+          if (!line.trim()) {
+            flush("");
+            continue;
+          }
+          if (line.startsWith("data:")) line = line.slice(5).trim();
+          if (!line) continue;
+          flush(line);
+        }
+      }
+      if (buf) flush(buf);
+      const blocks = [...textBlocks, ...toolBlocks];
+      return {
+        blocks,
+        stop_reason: toolBlocks.some((b) => b.type === "tool_use") ? "tool_use" : "end"
+      };
+    }
+    /* ────────────────────────────────────────────────────────── */
+    /*  Convert JSON of non-stream (= generateContent)        */
+    /* ────────────────────────────────────────────────────────── */
+    parseOneShot(data, model) {
+      const textBlocks = [];
+      const toolBlocks = [];
+      for (const cand of data.candidates ?? []) {
+        for (const part of cand.content?.parts ?? []) {
+          if (this.shouldExposeTextPart(part, model)) {
+            textBlocks.push({ type: "text", text: part.text });
+          }
+          if (part.functionCall) {
+            toolBlocks.push({
+              type: "tool_use",
+              id: this.genUUID(),
+              name: part.functionCall.name,
+              input: part.functionCall.args ?? {}
+            });
+          }
+          if (part.functionResponse) {
+            toolBlocks.push({
+              type: "tool_result",
+              tool_use_id: part.functionResponse.name,
+              content: JSON.stringify(part.functionResponse.response)
+            });
+          }
+        }
       }
-      await processChatWithOptionalTools({
-        hasTools: this.tools.length > 0,
-        runWithoutTools: async () => {
-          const res = await this.callKimi(messages, this.visionModel, true);
-          return this.handleStream(res, onPartialResponse);
-        },
-        runWithTools: () => this.visionChatOnce(messages, true, onPartialResponse),
-        onCompleteResponse,
-        toolErrorMessage: "processVisionChat received tool_calls. ChatProcessor must use visionChatOnce() loop when tools are enabled."
-      });
+      const blocks = [...textBlocks, ...toolBlocks];
+      return {
+        blocks,
+        stop_reason: toolBlocks.some((b) => b.type === "tool_use") ? "tool_use" : "end"
+      };
     }
-    /**
-     * Process chat messages with tools (text only)
-     */
+    /* ────────────────────────────────────────────────────────── */
+    /*  chatOnce (text)                                       */
+    /* ────────────────────────────────────────────────────────── */
     async chatOnce(messages, stream = true, onPartialResponse = () => {
     }, maxTokens) {
-      const res = await this.callKimi(messages, this.model, stream, maxTokens);
-      return this.parseResponse(res, stream, onPartialResponse);
+      const res = await this.callGemini(messages, this.model, stream, maxTokens);
+      return stream ? this.parseStream(res, onPartialResponse, this.model) : this.parseOneShot(await res.json(), this.model);
     }
-    /**
-     * Process vision chat messages with tools
-     */
+    /* ────────────────────────────────────────────────────────── */
+    /*  visionChatOnce (images)                               */
+    /* ────────────────────────────────────────────────────────── */
     async visionChatOnce(messages, stream = false, onPartialResponse = () => {
     }, maxTokens) {
-      if (!isKimiVisionModel(this.visionModel)) {
-        throw new Error(
-          `Model ${this.visionModel} does not support vision capabilities.`
-        );
-      }
-      const res = await this.callKimi(
+      const res = await this.callGemini(
         messages,
         this.visionModel,
         stream,
         maxTokens
       );
-      return this.parseResponse(res, stream, onPartialResponse);
-    }
-    async parseResponse(res, stream, onPartialResponse) {
-      return stream ? this.parseStream(res, onPartialResponse) : this.parseOneShot(await res.json());
-    }
-    async callKimi(messages, model, stream = false, maxTokens) {
-      const body = this.buildRequestBody(messages, model, stream, maxTokens);
-      const res = await ChatServiceHttpClient.post(this.endpoint, body, {
-        Authorization: `Bearer ${this.apiKey}`
-      });
-      return res;
-    }
-    /**
-     * Build request body (OpenAI-compatible Chat Completions)
-     */
-    buildRequestBody(messages, model, stream, maxTokens) {
-      const body = {
-        model,
-        stream,
-        messages
-      };
-      const tokenLimit = maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength);
-      if (tokenLimit !== void 0) {
-        body.max_tokens = tokenLimit;
-      }
-      if (this.responseFormat) {
-        body.response_format = this.responseFormat;
-      }
-      const effectiveThinking = this.tools.length > 0 ? { type: "disabled" } : this.thinking;
-      if (effectiveThinking) {
-        if (this.isSelfHostedEndpoint()) {
-          if (effectiveThinking.type === "disabled") {
-            body.chat_template_kwargs = { thinking: false };
-          }
-        } else {
-          body.thinking = effectiveThinking;
-        }
-      }
-      const tools = this.buildToolsDefinition();
-      if (tools.length > 0) {
-        body.tools = tools;
-        body.tool_choice = "auto";
-      }
-      return body;
-    }
-    isSelfHostedEndpoint() {
-      return this.normalizeEndpoint(this.endpoint) !== this.normalizeEndpoint(ENDPOINT_KIMI_CHAT_COMPLETIONS_API);
-    }
-    normalizeEndpoint(value) {
-      return value.replace(/\/+$/, "");
-    }
-    buildToolsDefinition() {
-      return buildOpenAICompatibleTools(this.tools, "chat-completions");
-    }
-    async handleStream(res, onPartial) {
-      return parseOpenAICompatibleTextStream(res, onPartial, {
-        onJsonError: (payload) => console.debug("Failed to parse SSE data:", payload)
-      });
+      return stream ? this.parseStream(res, onPartialResponse, this.visionModel) : this.parseOneShot(await res.json(), this.visionModel);
     }
-    /**
-     * Parse streaming response with tool support
-     */
-    async parseStream(res, onPartial) {
-      return parseOpenAICompatibleToolStream(res, onPartial, {
-        onJsonError: (payload) => console.debug("Failed to parse SSE data:", payload)
+    /* ────────────────────────────────────────────────────────── */
+    /*  UUID helper                                           */
+    /* ────────────────────────────────────────────────────────── */
+    genUUID() {
+      return typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0;
+        const v = c === "x" ? r : r & 3 | 8;
+        return v.toString(16);
       });
     }
-    /**
-     * Parse non-streaming response
-     */
-    parseOneShot(data) {
-      return parseOpenAICompatibleOneShot(data);
-    }
   };
 
-  // src/services/providers/kimi/KimiChatServiceProvider.ts
-  var KimiChatServiceProvider = class {
+  // src/services/providers/gemini/GeminiChatServiceProvider.ts
+  var GeminiChatServiceProvider = class {
     /**
      * Create a chat service instance
+     * @param options Service options
+     * @returns GeminiChatService instance
      */
     createChatService(options) {
-      const endpoint = this.resolveEndpoint(options);
-      const model = options.model || this.getDefaultModel();
       const visionModel = resolveVisionModel({
-        model,
+        model: options.model,
         visionModel: options.visionModel,
         defaultModel: this.getDefaultModel(),
-        defaultVisionModel: this.getDefaultVisionModel(),
-        supportsVisionForModel: (visionModel2) => this.supportsVisionForModel(visionModel2),
-        validate: "explicit"
+        defaultVisionModel: this.getDefaultModel(),
+        supportsVisionForModel: (model) => this.supportsVisionForModel(model),
+        validate: "resolved"
       });
-      const tools = options.tools;
-      const defaultThinking = options.thinking ?? { type: "enabled" };
-      const thinking = tools && tools.length > 0 ? { type: "disabled" } : defaultThinking;
-      return new KimiChatService(
+      return new GeminiChatService(
         options.apiKey,
-        model,
+        options.model || this.getDefaultModel(),
         visionModel,
-        tools,
-        endpoint,
-        options.responseLength,
-        options.responseFormat,
-        thinking
+        options.tools || [],
+        options.mcpServers || [],
+        options.responseLength
       );
     }
     /**
      * Get the provider name
+     * @returns Provider name ('gemini')
      */
     getProviderName() {
-      return "kimi";
+      return "gemini";
     }
     /**
      * Get the list of supported models
+     * @returns Array of supported model names
      */
     getSupportedModels() {
-      return [MODEL_KIMI_K2_6, MODEL_KIMI_K2_5];
+      return [...GEMINI_RECOMMENDED_MODELS];
     }
     /**
      * Get the default model
+     * @returns Default model name
      */
     getDefaultModel() {
-      return MODEL_KIMI_K2_6;
+      return MODEL_GEMINI_3_1_FLASH_LITE;
     }
     /**
-     * Get the default vision model
+     * Check if this provider supports vision (image processing)
+     * @returns Vision support status (true)
      */
-    getDefaultVisionModel() {
-      return MODEL_KIMI_K2_6;
+    supportsVision() {
+      return this.getVisionSupportLevel() !== "unsupported";
+    }
+    getVisionSupportLevel() {
+      return "supported";
+    }
+    /**
+     * Check if a specific model supports vision capabilities
+     * @param model The model name to check
+     * @returns True if the model supports vision, false otherwise
+     */
+    supportsVisionForModel(model) {
+      return GEMINI_VISION_SUPPORTED_MODELS.includes(model);
+    }
+    getVisionSupportLevelForModel(model) {
+      return this.supportsVisionForModel(model) ? "supported" : "unsupported";
+    }
+  };
+
+  // src/services/providers/geminiNano/GeminiNanoChatService.ts
+  function getLanguageModelAPI() {
+    if (typeof globalThis !== "undefined" && "LanguageModel" in globalThis) {
+      return globalThis.LanguageModel;
+    }
+    return void 0;
+  }
+  var GeminiNanoChatService = class {
+    constructor(options = {}) {
+      this.provider = "gemini-nano";
+      this.expectedInputLanguages = options.expectedInputLanguages ?? ["ja"];
+      this.expectedOutputLanguages = options.expectedOutputLanguages ?? ["ja"];
+      this._responseLength = options.responseLength;
+    }
+    getModel() {
+      return MODEL_GEMINI_NANO;
+    }
+    getVisionModel() {
+      return MODEL_GEMINI_NANO;
+    }
+    /**
+     * Process chat messages using Gemini Nano.
+     * Non-streaming: calls onPartialResponse once with the full response,
+     * then calls onCompleteResponse.
+     */
+    async processChat(messages, onPartialResponse, onCompleteResponse) {
+      const response = await this.generateResponse(messages);
+      onPartialResponse(response);
+      await onCompleteResponse(response);
+    }
+    async processVisionChat(_messages, _onPartialResponse, _onCompleteResponse) {
+      throw new Error("Gemini Nano does not support vision capabilities.");
+    }
+    async chatOnce(messages, _stream = false, onPartialResponse = () => {
+    }, _maxTokens) {
+      const response = await this.generateResponse(messages);
+      onPartialResponse(response);
+      return {
+        blocks: [{ type: "text", text: response }],
+        stop_reason: "end"
+      };
+    }
+    async visionChatOnce(_messages, _stream = false, _onPartialResponse = () => {
+    }, _maxTokens) {
+      throw new Error("Gemini Nano does not support vision capabilities.");
     }
     /**
-     * Check if this provider supports vision
+     * Core logic: extract system prompt, manage session, call prompt().
      */
-    supportsVision() {
-      return this.getVisionSupportLevel() !== "unsupported";
-    }
-    getVisionSupportLevel() {
-      return "supported";
+    async generateResponse(messages) {
+      const api = getLanguageModelAPI();
+      if (!api) {
+        throw new Error(
+          "Gemini Nano is not available in this environment. Chrome 138+ with Prompt API enabled is required."
+        );
+      }
+      const availability = await api.availability();
+      if (availability !== "available" && availability !== "downloadable") {
+        throw new Error(
+          `Gemini Nano Prompt API is not ready in this environment. LanguageModel.availability() returned "${availability}". Expected "available" or "downloadable".`
+        );
+      }
+      const systemMessages = messages.filter((m) => m.role === "system");
+      const systemPrompt = systemMessages.map((m) => m.content).join("\n");
+      const conversationMessages = messages.filter((m) => m.role !== "system").slice(-GEMINI_NANO_MAX_CONTEXT_MESSAGES);
+      const lastUserMessage = [...conversationMessages].reverse().find((m) => m.role === "user");
+      if (!lastUserMessage) {
+        throw new Error("No user message found in the provided messages.");
+      }
+      const session = await this.createSession(
+        api,
+        systemPrompt,
+        conversationMessages
+      );
+      try {
+        return await session.prompt(lastUserMessage.content);
+      } finally {
+        try {
+          session.destroy();
+        } catch {
+        }
+      }
     }
     /**
-     * Check if a specific model supports vision capabilities
+     * Create a new LanguageModel session with system prompt and context history.
+     * Context history (excluding the last user message) is embedded in the system prompt.
      */
-    supportsVisionForModel(model) {
-      return isKimiVisionModel(model);
-    }
-    getVisionSupportLevelForModel(model) {
-      return this.supportsVisionForModel(model) ? "supported" : "unsupported";
+    async createSession(api, systemPrompt, contextHistory) {
+      let prompt = this.buildSystemPrompt(systemPrompt);
+      const historyMessages = contextHistory.slice(0, -1);
+      if (historyMessages.length > 0) {
+        const history = historyMessages.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n");
+        prompt += "\n\nThe following is the prior conversation history. Use it as context for your response:\n" + history;
+      }
+      return api.create({
+        systemPrompt: prompt,
+        expectedInputs: [
+          { type: "text", languages: this.expectedInputLanguages }
+        ],
+        expectedOutputs: [
+          { type: "text", languages: this.expectedOutputLanguages }
+        ]
+      });
     }
-    resolveEndpoint(options) {
-      if (options.endpoint) {
-        return this.normalizeEndpoint(options.endpoint);
+    buildSystemPrompt(systemPrompt) {
+      const promptParts = [];
+      if (systemPrompt) {
+        promptParts.push(systemPrompt);
       }
-      if (options.baseUrl) {
-        const baseUrl = this.normalizeEndpoint(options.baseUrl);
-        if (baseUrl.endsWith("/chat/completions")) {
-          return baseUrl;
-        }
-        return `${baseUrl}/chat/completions`;
+      const lengthInstruction = this.getResponseLengthInstruction();
+      if (lengthInstruction) {
+        promptParts.push(lengthInstruction);
       }
-      return ENDPOINT_KIMI_CHAT_COMPLETIONS_API;
+      return promptParts.join("\n\n");
     }
-    normalizeEndpoint(value) {
-      return value.replace(/\/+$/, "");
+    getResponseLengthInstruction() {
+      if (!this._responseLength) {
+        return void 0;
+      }
+      const maxTokens = MAX_TOKENS_BY_LENGTH[this._responseLength];
+      if (!maxTokens) {
+        return void 0;
+      }
+      return `Please keep your response concise, within approximately ${maxTokens} tokens.`;
     }
   };
 
-  // src/services/providers/openai/responsesParser.ts
-  async function parseOpenAIResponsesStream(res, onPartial) {
-    const reader = res.body.getReader();
-    const dec = new TextDecoder();
-    const textBlocks = [];
-    const toolCallsMap = /* @__PURE__ */ new Map();
-    let responseStatus;
-    let incompleteDetails;
-    let usage;
-    let buf = "";
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buf += dec.decode(value, { stream: true });
-      let eventType = "";
-      let eventData = "";
-      const lines = buf.split("\n");
-      buf = lines.pop() || "";
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
-        if (line.startsWith("event:")) {
-          eventType = line.slice(6).trim();
-        } else if (line.startsWith("data:")) {
-          eventData = line.slice(5).trim();
-        } else if (line === "" && eventType && eventData) {
-          try {
-            const json = JSON.parse(eventData);
-            handleResponsesSSEEvent(
-              eventType,
-              json,
-              onPartial,
-              textBlocks,
-              toolCallsMap,
-              (metadata) => {
-                if (metadata.responseStatus !== void 0) {
-                  responseStatus = metadata.responseStatus;
-                }
-                if (metadata.incompleteDetails !== void 0) {
-                  incompleteDetails = metadata.incompleteDetails;
-                }
-                if (metadata.usage !== void 0) {
-                  usage = metadata.usage;
-                }
-              }
-            );
-          } catch {
-            console.warn("Failed to parse SSE data:", eventData);
-          }
-          eventType = "";
-          eventData = "";
-        }
-      }
+  // src/services/providers/geminiNano/GeminiNanoChatServiceProvider.ts
+  var GeminiNanoChatServiceProvider = class {
+    createChatService(options) {
+      return new GeminiNanoChatService({
+        expectedInputLanguages: options.expectedInputLanguages,
+        expectedOutputLanguages: options.expectedOutputLanguages,
+        responseLength: options.responseLength
+      });
     }
-    const toolBlocks = Array.from(toolCallsMap.values()).map(
-      (tool) => ({
-        type: "tool_use",
-        id: tool.id,
-        name: tool.name,
-        input: tool.input || {}
-      })
-    );
-    return {
-      blocks: [...textBlocks, ...toolBlocks],
-      stop_reason: toolBlocks.length ? "tool_use" : "end",
-      truncated: responseStatus === "incomplete",
-      response_status: responseStatus,
-      incomplete_details: incompleteDetails,
-      usage
-    };
-  }
-  function handleResponsesSSEEvent(eventType, data, onPartial, textBlocks, toolCallsMap, onMetadata) {
-    switch (eventType) {
-      case "response.output_item.added":
-        if (data.item?.type === "message" && Array.isArray(data.item.content)) {
-          data.item.content.forEach((c) => {
-            if (c.type === "output_text" && c.text) {
-              onPartial(c.text);
-              StreamTextAccumulator.append(textBlocks, c.text);
-            }
-          });
-        } else if (data.item?.type === "function_call") {
-          toolCallsMap.set(data.item.id, {
-            id: data.item.id,
-            name: data.item.name,
-            input: data.item.arguments ? JSON.parse(data.item.arguments) : {}
-          });
-        }
-        break;
-      case "response.content_part.added":
-        if (data.part?.type === "output_text" && typeof data.part.text === "string") {
-          onPartial(data.part.text);
-          StreamTextAccumulator.append(textBlocks, data.part.text);
-        }
-        break;
-      case "response.output_text.delta":
-      case "response.content_part.delta": {
-        const deltaText = typeof data.delta === "string" ? data.delta : data.delta?.text ?? "";
-        if (deltaText) {
-          onPartial(deltaText);
-          StreamTextAccumulator.append(textBlocks, deltaText);
-        }
-        break;
-      }
-      case "response.output_text.done":
-      case "response.content_part.done":
-      case "response.reasoning.started":
-      case "response.reasoning.delta":
-      case "response.reasoning.done":
-        break;
-      case "response.completed":
-        onMetadata(extractResponsesMetadata(data, "completed"));
-        break;
-      case "response.incomplete":
-        onMetadata(extractResponsesMetadata(data, "incomplete"));
-        break;
-      default:
-        break;
+    getProviderName() {
+      return "gemini-nano";
     }
-  }
-  function extractResponsesMetadata(data, fallbackStatus) {
-    const response = data?.response ?? data;
-    return {
-      responseStatus: response?.status ?? fallbackStatus,
-      incompleteDetails: response?.incomplete_details ?? null,
-      usage: response?.usage
-    };
-  }
-  function parseOpenAIResponsesOneShot(data) {
-    const blocks = [];
-    if (data.output && Array.isArray(data.output)) {
-      data.output.forEach((outputItem) => {
-        if (outputItem.type === "message" && outputItem.content) {
-          outputItem.content.forEach((content) => {
-            if (content.type === "output_text" && content.text) {
-              blocks.push({ type: "text", text: content.text });
-            }
-          });
-        }
-        if (outputItem.type === "function_call") {
-          blocks.push({
-            type: "tool_use",
-            id: outputItem.id,
-            name: outputItem.name,
-            input: outputItem.arguments ? JSON.parse(outputItem.arguments) : {}
-          });
-        }
-      });
+    getSupportedModels() {
+      return [MODEL_GEMINI_NANO];
+    }
+    getDefaultModel() {
+      return MODEL_GEMINI_NANO;
+    }
+    supportsVision() {
+      return false;
+    }
+    getVisionSupportLevel() {
+      return "unsupported";
     }
-    return {
-      blocks,
-      stop_reason: blocks.some((b) => b.type === "tool_use") ? "tool_use" : "end",
-      truncated: data?.status === "incomplete",
-      response_status: data?.status,
-      incomplete_details: data?.incomplete_details ?? null,
-      usage: data?.usage
-    };
-  }
-
-  // src/services/providers/openai/OpenAIChatService.ts
-  var GPT5_RESPONSE_LENGTH_MIN_TOKENS = {
-    [CHAT_RESPONSE_LENGTH.VERY_SHORT]: 800,
-    [CHAT_RESPONSE_LENGTH.SHORT]: 1200,
-    [CHAT_RESPONSE_LENGTH.MEDIUM]: 2e3,
-    [CHAT_RESPONSE_LENGTH.LONG]: 3e3,
-    [CHAT_RESPONSE_LENGTH.VERY_LONG]: 8e3,
-    [CHAT_RESPONSE_LENGTH.DEEP]: 25e3
-  };
-  var GPT5_REASONING_MIN_TOKENS = {
-    none: 1200,
-    minimal: 1600,
-    low: 2500,
-    medium: 4e3,
-    high: 8e3,
-    xhigh: 12e3
   };
-  var OpenAIChatService = class {
+
+  // src/services/providers/kimi/KimiChatService.ts
+  var KimiChatService = class {
     /**
      * Constructor
-     * @param apiKey OpenAI API key
+     * @param apiKey Kimi API key
      * @param model Name of the model to use
      * @param visionModel Name of the vision model
      */
-    constructor(apiKey, model = MODEL_GPT_4O_MINI, visionModel = MODEL_GPT_4O_MINI, tools, endpoint = ENDPOINT_OPENAI_CHAT_COMPLETIONS_API, mcpServers = [], responseLength, verbosity, reasoning_effort, enableReasoningSummary = false, provider = "openai", validateVisionModel = true) {
-      this.provider = provider;
+    constructor(apiKey, model = MODEL_KIMI_K2_6, visionModel = MODEL_KIMI_K2_6, tools, endpoint = ENDPOINT_KIMI_CHAT_COMPLETIONS_API, responseLength, responseFormat, thinking) {
+      /** Provider name */
+      this.provider = "kimi";
       this.apiKey = apiKey;
       this.model = model;
       this.tools = tools || [];
       this.endpoint = endpoint;
-      this.mcpServers = mcpServers;
       this.responseLength = responseLength;
-      this.verbosity = verbosity;
-      this.reasoning_effort = reasoning_effort;
-      this.enableReasoningSummary = enableReasoningSummary;
-      if (validateVisionModel && !VISION_SUPPORTED_MODELS.includes(visionModel)) {
-        throw new Error(
-          `Model ${visionModel} does not support vision capabilities.`
-        );
-      }
+      this.responseFormat = responseFormat;
+      this.thinking = thinking ?? { type: "enabled" };
       this.visionModel = visionModel;
     }
     /**
      * Get the current model name
-     * @returns Model name
      */
     getModel() {
       return this.model;
     }
     /**
      * Get the current vision model name
-     * @returns Vision model name
      */
     getVisionModel() {
       return this.visionModel;
     }
     /**
      * Process chat messages
-     * @param messages Array of messages to send
-     * @param onPartialResponse Callback to receive each part of streaming response
-     * @param onCompleteResponse Callback to execute when response is complete
      */
     async processChat(messages, onPartialResponse, onCompleteResponse) {
       await processChatWithOptionalTools({
         hasTools: this.tools.length > 0,
         runWithoutTools: async () => {
-          const res = await this.callOpenAI(messages, this.model, true);
-          const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
-          try {
-            if (isResponsesAPI) {
-              const result = await parseOpenAIResponsesStream(
-                res,
-                onPartialResponse
-              );
-              return StreamTextAccumulator.getFullText(result.blocks);
-            }
-            return this.handleStream(res, onPartialResponse);
-          } catch (error) {
-            console.error("[processChat] Error in streaming/completion:", error);
-            throw error;
-          }
+          const res = await this.callKimi(messages, this.model, true);
+          return this.handleStream(res, onPartialResponse);
         },
         runWithTools: () => this.chatOnce(messages, true, onPartialResponse),
         onCompleteResponse,
@@ -3105,68 +3378,43 @@ If it's in another language, summarize in that language.
     }
     /**
      * Process chat messages with images
-     * @param messages Array of messages to send (including images)
-     * @param onPartialResponse Callback to receive each part of streaming response
-     * @param onCompleteResponse Callback to execute when response is complete
-     * @throws Error if the selected model doesn't support vision
      */
     async processVisionChat(messages, onPartialResponse, onCompleteResponse) {
-      try {
-        await processChatWithOptionalTools({
-          hasTools: this.tools.length > 0,
-          runWithoutTools: async () => {
-            const res = await this.callOpenAI(messages, this.visionModel, true);
-            const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
-            try {
-              if (isResponsesAPI) {
-                const result = await parseOpenAIResponsesStream(
-                  res,
-                  onPartialResponse
-                );
-                return StreamTextAccumulator.getFullText(result.blocks);
-              }
-              return this.handleStream(res, onPartialResponse);
-            } catch (streamError) {
-              console.error(
-                "[processVisionChat] Error in streaming/completion:",
-                streamError
-              );
-              throw streamError;
-            }
-          },
-          runWithTools: () => this.visionChatOnce(messages, true, onPartialResponse),
-          onCompleteResponse,
-          toolErrorMessage: "processVisionChat received tool_calls. ChatProcessor must use visionChatOnce() loop when tools are enabled."
-        });
-      } catch (error) {
-        console.error("Error in processVisionChat:", error);
-        throw error;
+      if (!isKimiVisionModel(this.visionModel)) {
+        throw new Error(
+          `Model ${this.visionModel} does not support vision capabilities.`
+        );
       }
+      await processChatWithOptionalTools({
+        hasTools: this.tools.length > 0,
+        runWithoutTools: async () => {
+          const res = await this.callKimi(messages, this.visionModel, true);
+          return this.handleStream(res, onPartialResponse);
+        },
+        runWithTools: () => this.visionChatOnce(messages, true, onPartialResponse),
+        onCompleteResponse,
+        toolErrorMessage: "processVisionChat received tool_calls. ChatProcessor must use visionChatOnce() loop when tools are enabled."
+      });
     }
     /**
      * Process chat messages with tools (text only)
-     * @param messages Array of messages to send
-     * @param stream Whether to use streaming
-     * @param onPartialResponse Callback for partial responses
-     * @param maxTokens Maximum tokens for response (optional)
-     * @returns Tool chat completion
      */
     async chatOnce(messages, stream = true, onPartialResponse = () => {
     }, maxTokens) {
-      const res = await this.callOpenAI(messages, this.model, stream, maxTokens);
+      const res = await this.callKimi(messages, this.model, stream, maxTokens);
       return this.parseResponse(res, stream, onPartialResponse);
     }
     /**
      * Process vision chat messages with tools
-     * @param messages Array of messages to send (including images)
-     * @param stream Whether to use streaming
-     * @param onPartialResponse Callback for partial responses
-     * @param maxTokens Maximum tokens for response (optional)
-     * @returns Tool chat completion
      */
     async visionChatOnce(messages, stream = false, onPartialResponse = () => {
     }, maxTokens) {
-      const res = await this.callOpenAI(
+      if (!isKimiVisionModel(this.visionModel)) {
+        throw new Error(
+          `Model ${this.visionModel} does not support vision capabilities.`
+        );
+      }
+      const res = await this.callKimi(
         messages,
         this.visionModel,
         stream,
@@ -3174,205 +3422,258 @@ If it's in another language, summarize in that language.
       );
       return this.parseResponse(res, stream, onPartialResponse);
     }
-    /**
-     * Parse response based on endpoint type
-     */
     async parseResponse(res, stream, onPartialResponse) {
-      const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
-      if (isResponsesAPI) {
-        return stream ? parseOpenAIResponsesStream(res, onPartialResponse) : parseOpenAIResponsesOneShot(await res.json());
-      }
       return stream ? this.parseStream(res, onPartialResponse) : this.parseOneShot(await res.json());
     }
-    async callOpenAI(messages, model, stream = false, maxTokens) {
+    async callKimi(messages, model, stream = false, maxTokens) {
       const body = this.buildRequestBody(messages, model, stream, maxTokens);
-      const headers = {};
-      const shouldSendAuthorization = this.provider !== "openai-compatible" || this.apiKey.trim() !== "";
-      if (shouldSendAuthorization) {
-        headers.Authorization = `Bearer ${this.apiKey}`;
-      }
-      const res = await ChatServiceHttpClient.post(this.endpoint, body, headers);
+      const res = await ChatServiceHttpClient.post(this.endpoint, body, {
+        Authorization: `Bearer ${this.apiKey}`
+      });
       return res;
     }
     /**
-     * Build request body based on the endpoint type
+     * Build request body (OpenAI-compatible Chat Completions)
+     */
+    buildRequestBody(messages, model, stream, maxTokens) {
+      const body = {
+        model,
+        stream,
+        messages
+      };
+      const tokenLimit = maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength);
+      if (tokenLimit !== void 0) {
+        body.max_tokens = tokenLimit;
+      }
+      if (this.responseFormat) {
+        body.response_format = this.responseFormat;
+      }
+      const effectiveThinking = this.tools.length > 0 ? { type: "disabled" } : this.thinking;
+      if (effectiveThinking) {
+        if (this.isSelfHostedEndpoint()) {
+          if (effectiveThinking.type === "disabled") {
+            body.chat_template_kwargs = { thinking: false };
+          }
+        } else {
+          body.thinking = effectiveThinking;
+        }
+      }
+      const tools = this.buildToolsDefinition();
+      if (tools.length > 0) {
+        body.tools = tools;
+        body.tool_choice = "auto";
+      }
+      return body;
+    }
+    isSelfHostedEndpoint() {
+      return this.normalizeEndpoint(this.endpoint) !== this.normalizeEndpoint(ENDPOINT_KIMI_CHAT_COMPLETIONS_API);
+    }
+    normalizeEndpoint(value) {
+      return value.replace(/\/+$/, "");
+    }
+    buildToolsDefinition() {
+      return buildOpenAICompatibleTools(this.tools, "chat-completions");
+    }
+    async handleStream(res, onPartial) {
+      return parseOpenAICompatibleTextStream(res, onPartial, {
+        onJsonError: (payload) => console.debug("Failed to parse SSE data:", payload)
+      });
+    }
+    /**
+     * Parse streaming response with tool support
+     */
+    async parseStream(res, onPartial) {
+      return parseOpenAICompatibleToolStream(res, onPartial, {
+        onJsonError: (payload) => console.debug("Failed to parse SSE data:", payload)
+      });
+    }
+    /**
+     * Parse non-streaming response
+     */
+    parseOneShot(data) {
+      return parseOpenAICompatibleOneShot(data);
+    }
+  };
+
+  // src/services/providers/kimi/KimiChatServiceProvider.ts
+  var KimiChatServiceProvider = class {
+    /**
+     * Create a chat service instance
+     */
+    createChatService(options) {
+      const endpoint = this.resolveEndpoint(options);
+      const model = options.model || this.getDefaultModel();
+      const visionModel = resolveVisionModel({
+        model,
+        visionModel: options.visionModel,
+        defaultModel: this.getDefaultModel(),
+        defaultVisionModel: this.getDefaultVisionModel(),
+        supportsVisionForModel: (visionModel2) => this.supportsVisionForModel(visionModel2),
+        validate: "explicit"
+      });
+      const tools = options.tools;
+      const defaultThinking = options.thinking ?? { type: "enabled" };
+      const thinking = tools && tools.length > 0 ? { type: "disabled" } : defaultThinking;
+      return new KimiChatService(
+        options.apiKey,
+        model,
+        visionModel,
+        tools,
+        endpoint,
+        options.responseLength,
+        options.responseFormat,
+        thinking
+      );
+    }
+    /**
+     * Get the provider name
+     */
+    getProviderName() {
+      return "kimi";
+    }
+    /**
+     * Get the list of supported models
      */
-    buildRequestBody(messages, model, stream, maxTokens) {
-      const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
-      this.validateMCPCompatibility();
-      const body = {
-        model,
-        stream
-      };
-      const tokenLimit = this.resolveTokenLimit(model, maxTokens);
-      if (isResponsesAPI) {
-        if (tokenLimit !== void 0) {
-          body.max_output_tokens = tokenLimit;
-        }
-      } else {
-        if (tokenLimit !== void 0) {
-          if (this.provider === "openai-compatible") {
-            body.max_tokens = tokenLimit;
-          } else {
-            body.max_completion_tokens = tokenLimit;
-          }
-        }
-      }
-      if (isResponsesAPI) {
-        body.input = this.cleanMessagesForResponsesAPI(messages);
-      } else {
-        body.messages = messages;
-      }
-      if (isGPT5Model(model)) {
-        if (isResponsesAPI) {
-          if (this.reasoning_effort) {
-            body.reasoning = {
-              ...body.reasoning,
-              effort: this.reasoning_effort
-            };
-            if (this.enableReasoningSummary) {
-              body.reasoning.summary = "auto";
-            }
-          }
-          if (this.verbosity) {
-            body.text = {
-              ...body.text,
-              format: { type: "text" },
-              verbosity: this.verbosity
-            };
-          }
-        } else {
-          if (this.reasoning_effort) {
-            body.reasoning_effort = this.reasoning_effort;
-          }
-          if (this.verbosity) {
-            body.verbosity = this.verbosity;
-          }
-        }
-      }
-      const tools = this.buildToolsDefinition();
-      if (tools.length > 0) {
-        body.tools = tools;
-        if (!isResponsesAPI) {
-          body.tool_choice = "auto";
-        }
-      }
-      return body;
-    }
-    resolveTokenLimit(model, maxTokens) {
-      if (maxTokens !== void 0) {
-        return maxTokens;
-      }
-      const baseTokenLimit = this.provider === "openai-compatible" ? this.responseLength !== void 0 ? getMaxTokensForResponseLength(this.responseLength) : void 0 : getMaxTokensForResponseLength(this.responseLength);
-      if (this.provider !== "openai" || !isGPT5Model(model) || this.responseLength === void 0) {
-        return baseTokenLimit;
-      }
-      const effectiveReasoningEffort = this.reasoning_effort ?? getDefaultReasoningEffortForGPT5Model(model);
-      return Math.max(
-        baseTokenLimit ?? 0,
-        GPT5_RESPONSE_LENGTH_MIN_TOKENS[this.responseLength],
-        GPT5_REASONING_MIN_TOKENS[effectiveReasoningEffort]
-      );
+    getSupportedModels() {
+      return [MODEL_KIMI_K2_6, MODEL_KIMI_K2_5];
     }
     /**
-     * Validate MCP servers compatibility with the current endpoint
+     * Get the default model
      */
-    validateMCPCompatibility() {
-      if (this.mcpServers.length > 0 && this.endpoint === ENDPOINT_OPENAI_CHAT_COMPLETIONS_API) {
-        throw new Error(
-          `MCP servers are not supported with Chat Completions API. Current endpoint: ${this.endpoint}. Please use OpenAI Responses API endpoint: ${ENDPOINT_OPENAI_RESPONSES_API}. MCP tools are only available in the Responses API endpoint.`
-        );
-      }
+    getDefaultModel() {
+      return MODEL_KIMI_K2_6;
     }
     /**
-     * Clean messages for Responses API (remove timestamp and other extra properties)
+     * Get the default vision model
      */
-    cleanMessagesForResponsesAPI(messages) {
-      return messages.map((msg) => {
-        const role = msg.role === "tool" ? "user" : msg.role;
-        const cleanMsg = {
-          role
-        };
-        if (typeof msg.content === "string") {
-          cleanMsg.content = msg.content;
-        } else if (Array.isArray(msg.content)) {
-          cleanMsg.content = msg.content.map((block) => {
-            if (block.type === "text") {
-              return {
-                type: "input_text",
-                text: block.text
-              };
-            } else if (block.type === "image_url") {
-              return {
-                type: "input_image",
-                image_url: block.image_url.url
-                // Extract the URL string directly
-              };
-            }
-            return block;
-          });
-        } else {
-          cleanMsg.content = msg.content;
-        }
-        return cleanMsg;
-      });
+    getDefaultVisionModel() {
+      return MODEL_KIMI_K2_6;
     }
     /**
-     * Build tools definition based on the endpoint type
+     * Check if this provider supports vision
      */
-    buildToolsDefinition() {
-      const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
-      const toolDefs = [];
-      if (this.tools.length > 0) {
-        toolDefs.push(
-          ...buildOpenAICompatibleTools(
-            this.tools,
-            isResponsesAPI ? "responses" : "chat-completions"
-          )
-        );
-      }
-      if (this.mcpServers.length > 0 && isResponsesAPI) {
-        toolDefs.push(...this.buildMCPToolsDefinition());
-      }
-      return toolDefs;
+    supportsVision() {
+      return this.getVisionSupportLevel() !== "unsupported";
+    }
+    getVisionSupportLevel() {
+      return "supported";
     }
     /**
-     * Build MCP tools definition for Responses API
+     * Check if a specific model supports vision capabilities
      */
-    buildMCPToolsDefinition() {
-      return this.mcpServers.map((server) => {
-        const mcpDef = {
-          type: "mcp",
-          // Using 'mcp' as indicated by the error message
-          server_label: server.name,
-          // Use server_label as required by API
-          server_url: server.url
-          // Use server_url instead of url
-        };
-        if (server.require_approval) {
-          mcpDef.require_approval = server.require_approval;
-        }
-        if (server.tool_configuration?.allowed_tools) {
-          mcpDef.allowed_tools = server.tool_configuration.allowed_tools;
-        }
-        if (server.authorization_token) {
-          mcpDef.headers = {
-            Authorization: `Bearer ${server.authorization_token}`
-          };
+    supportsVisionForModel(model) {
+      return isKimiVisionModel(model);
+    }
+    getVisionSupportLevelForModel(model) {
+      return this.supportsVisionForModel(model) ? "supported" : "unsupported";
+    }
+    resolveEndpoint(options) {
+      if (options.endpoint) {
+        return this.normalizeEndpoint(options.endpoint);
+      }
+      if (options.baseUrl) {
+        const baseUrl = this.normalizeEndpoint(options.baseUrl);
+        if (baseUrl.endsWith("/chat/completions")) {
+          return baseUrl;
         }
-        return mcpDef;
-      });
+        return `${baseUrl}/chat/completions`;
+      }
+      return ENDPOINT_KIMI_CHAT_COMPLETIONS_API;
     }
-    async handleStream(res, onPartial) {
-      return parseOpenAICompatibleTextStream(res, onPartial);
+    normalizeEndpoint(value) {
+      return value.replace(/\/+$/, "");
     }
-    async parseStream(res, onPartial) {
-      return parseOpenAICompatibleToolStream(res, onPartial, {
-        appendTextBlock: StreamTextAccumulator.addTextBlock
+  };
+
+  // src/services/providers/mistral/MistralChatService.ts
+  var MistralChatService = class extends OpenAIChatService {
+    constructor(apiKey, model = MODEL_MISTRAL_SMALL_LATEST, visionModel = model, tools, endpoint = ENDPOINT_MISTRAL_CHAT_COMPLETIONS_API, responseLength, reasoningEffort) {
+      super(
+        apiKey,
+        model,
+        visionModel,
+        tools,
+        endpoint,
+        [],
+        responseLength,
+        void 0,
+        reasoningEffort,
+        false,
+        "mistral",
+        false
+      );
+    }
+  };
+
+  // src/services/providers/mistral/MistralChatServiceProvider.ts
+  var MistralChatServiceProvider = class {
+    createChatService(options) {
+      this.validateRequiredOptions(options);
+      const model = options.model || this.getDefaultModel();
+      const visionModel = resolveVisionModel({
+        model,
+        visionModel: options.visionModel,
+        defaultModel: this.getDefaultModel(),
+        defaultVisionModel: this.getDefaultVisionModel(),
+        supportsVisionForModel: (targetModel) => this.supportsVisionForModel(targetModel),
+        validate: "explicit"
       });
+      const tools = options.tools;
+      const reasoningEffort = isMistralReasoningEffortModel(model) ? options.reasoning_effort : void 0;
+      return new MistralChatService(
+        options.apiKey,
+        model,
+        visionModel,
+        tools,
+        this.resolveEndpoint(options),
+        options.responseLength,
+        reasoningEffort
+      );
     }
-    parseOneShot(data) {
-      return parseOpenAICompatibleOneShot(data);
+    getProviderName() {
+      return "mistral";
+    }
+    getSupportedModels() {
+      return [...MISTRAL_SUPPORTED_MODELS];
+    }
+    getDefaultModel() {
+      return MODEL_MISTRAL_SMALL_LATEST;
+    }
+    getDefaultVisionModel() {
+      return MODEL_MISTRAL_SMALL_LATEST;
+    }
+    supportsVision() {
+      return this.getVisionSupportLevel() !== "unsupported";
+    }
+    getVisionSupportLevel() {
+      return "supported";
+    }
+    supportsVisionForModel(model) {
+      return isMistralVisionModel(model);
+    }
+    getVisionSupportLevelForModel(model) {
+      return this.supportsVisionForModel(model) ? "supported" : "unsupported";
+    }
+    validateRequiredOptions(options) {
+      if (!options.apiKey?.trim()) {
+        throw new Error("mistral provider requires apiKey.");
+      }
+    }
+    resolveEndpoint(options) {
+      if (options.endpoint) {
+        return this.normalizeUrl(options.endpoint);
+      }
+      if (options.baseUrl) {
+        const baseUrl = this.normalizeUrl(options.baseUrl);
+        if (baseUrl.endsWith("/chat/completions")) {
+          return baseUrl;
+        }
+        return `${baseUrl}/chat/completions`;
+      }
+      return ENDPOINT_MISTRAL_CHAT_COMPLETIONS_API;
+    }
+    normalizeUrl(value) {
+      return value.trim().replace(/\/+$/, "");
     }
   };
 
@@ -4449,7 +4750,9 @@ If it's in another language, summarize in that language.
     new OpenRouterChatServiceProvider(),
     new ZAIChatServiceProvider(),
     new XAIChatServiceProvider(),
-    new KimiChatServiceProvider()
+    new KimiChatServiceProvider(),
+    new DeepSeekChatServiceProvider(),
+    new MistralChatServiceProvider()
   ];
 
   // src/services/ChatServiceFactory.ts