@aituber-onair/chat 0.10.0 → 0.11.1

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

@@ -62,6 +62,7 @@ var AITuberOnAirChat = (() => {
     MODEL_CLAUDE_4_5_HAIKU: () => MODEL_CLAUDE_4_5_HAIKU,
     MODEL_CLAUDE_4_5_OPUS: () => MODEL_CLAUDE_4_5_OPUS,
     MODEL_CLAUDE_4_5_SONNET: () => MODEL_CLAUDE_4_5_SONNET,
+    MODEL_CLAUDE_4_6_OPUS: () => MODEL_CLAUDE_4_6_OPUS,
     MODEL_CLAUDE_4_OPUS: () => MODEL_CLAUDE_4_OPUS,
     MODEL_CLAUDE_4_SONNET: () => MODEL_CLAUDE_4_SONNET,
     MODEL_GEMINI_2_0_FLASH: () => MODEL_GEMINI_2_0_FLASH,
@@ -123,6 +124,7 @@ var AITuberOnAirChat = (() => {
     ZAI_VISION_SUPPORTED_MODELS: () => ZAI_VISION_SUPPORTED_MODELS,
     allowsReasoningMinimal: () => allowsReasoningMinimal,
     allowsReasoningNone: () => allowsReasoningNone,
+    buildOpenAICompatibleTools: () => buildOpenAICompatibleTools,
     getMaxTokensForResponseLength: () => getMaxTokensForResponseLength,
     installGASFetch: () => installGASFetch,
     isGPT5Model: () => isGPT5Model,
@@ -131,6 +133,11 @@ var AITuberOnAirChat = (() => {
     isOpenRouterVisionModel: () => isOpenRouterVisionModel,
     isZaiToolStreamModel: () => isZaiToolStreamModel,
     isZaiVisionModel: () => isZaiVisionModel,
+    parseOpenAICompatibleOneShot: () => parseOpenAICompatibleOneShot,
+    parseOpenAICompatibleTextStream: () => parseOpenAICompatibleTextStream,
+    parseOpenAICompatibleToolStream: () => parseOpenAICompatibleToolStream,
+    processChatWithOptionalTools: () => processChatWithOptionalTools,
+    resolveVisionModel: () => resolveVisionModel,
     runOnceText: () => runOnceText,
     screenplayToText: () => screenplayToText,
     textToScreenplay: () => textToScreenplay,
@@ -211,6 +218,7 @@ var AITuberOnAirChat = (() => {
   var MODEL_CLAUDE_4_5_SONNET = "claude-sonnet-4-5-20250929";
   var MODEL_CLAUDE_4_5_HAIKU = "claude-haiku-4-5-20251001";
   var MODEL_CLAUDE_4_5_OPUS = "claude-opus-4-5-20251101";
+  var MODEL_CLAUDE_4_6_OPUS = "claude-opus-4-6";
   var CLAUDE_VISION_SUPPORTED_MODELS = [
     MODEL_CLAUDE_3_HAIKU,
     MODEL_CLAUDE_3_5_HAIKU,
@@ -220,7 +228,8 @@ var AITuberOnAirChat = (() => {
     MODEL_CLAUDE_4_OPUS,
     MODEL_CLAUDE_4_5_SONNET,
     MODEL_CLAUDE_4_5_HAIKU,
-    MODEL_CLAUDE_4_5_OPUS
+    MODEL_CLAUDE_4_5_OPUS,
+    MODEL_CLAUDE_4_6_OPUS
   ];
 
   // src/constants/openrouter.ts
@@ -365,43 +374,6 @@ If it's in English, summarize in English.
 If it's in another language, summarize in that language.
 `;
 
-  // src/utils/streamTextAccumulator.ts
-  var StreamTextAccumulator = class {
-    /**
-     * Append text to the blocks array, merging with the last block if it's a text block
-     * @param blocks Array of chat blocks
-     * @param text Text to append
-     */
-    static append(blocks, text) {
-      if (!text) return;
-      const lastBlock = blocks[blocks.length - 1];
-      if (lastBlock && lastBlock.type === "text") {
-        lastBlock.text += text;
-      } else {
-        blocks.push({ type: "text", text });
-      }
-    }
-    /**
-     * Get the full concatenated text from all text blocks
-     * @param blocks Array of chat blocks
-     * @returns Concatenated text from all text blocks
-     */
-    static getFullText(blocks) {
-      return blocks.filter(
-        (block) => block.type === "text"
-      ).map((block) => block.text).join("");
-    }
-    /**
-     * Add a text block without merging
-     * @param blocks Array of chat blocks
-     * @param text Text to add as a new block
-     */
-    static addTextBlock(blocks, text) {
-      if (!text) return;
-      blocks.push({ type: "text", text });
-    }
-  };
-
   // src/utils/chatServiceHttpClient.ts
   var HttpError = class extends Error {
     constructor(status, statusText, body) {
@@ -528,32 +500,311 @@ If it's in another language, summarize in that language.
   _ChatServiceHttpClient.fetchImpl = (u, i) => fetch(u, i);
   var ChatServiceHttpClient = _ChatServiceHttpClient;
 
-  // src/services/providers/openai/OpenAIChatService.ts
-  var OpenAIChatService = class {
+  // src/utils/streamTextAccumulator.ts
+  var StreamTextAccumulator = class {
+    /**
+     * Append text to the blocks array, merging with the last block if it's a text block
+     * @param blocks Array of chat blocks
+     * @param text Text to append
+     */
+    static append(blocks, text) {
+      if (!text) return;
+      const lastBlock = blocks[blocks.length - 1];
+      if (lastBlock && lastBlock.type === "text") {
+        lastBlock.text += text;
+      } else {
+        blocks.push({ type: "text", text });
+      }
+    }
+    /**
+     * Get the full concatenated text from all text blocks
+     * @param blocks Array of chat blocks
+     * @returns Concatenated text from all text blocks
+     */
+    static getFullText(blocks) {
+      return blocks.filter(
+        (block) => block.type === "text"
+      ).map((block) => block.text).join("");
+    }
+    /**
+     * Add a text block without merging
+     * @param blocks Array of chat blocks
+     * @param text Text to add as a new block
+     */
+    static addTextBlock(blocks, text) {
+      if (!text) return;
+      blocks.push({ type: "text", text });
+    }
+  };
+
+  // src/utils/emotionParser.ts
+  var emotions = ["happy", "sad", "angry", "surprised", "neutral"];
+  var EMOTION_TAG_REGEX = /\[([a-z]+)\]/i;
+  var EMOTION_TAG_CLEANUP_REGEX = /\[[a-z]+\]\s*/gi;
+  var EmotionParser = class {
+    /**
+     * Extract emotion from text and return clean text
+     * @param text Text that may contain emotion tags like [happy]
+     * @returns Object containing extracted emotion and clean text
+     */
+    static extractEmotion(text) {
+      const match = text.match(EMOTION_TAG_REGEX);
+      if (match) {
+        const emotion = match[1].toLowerCase();
+        const cleanText = text.replace(EMOTION_TAG_CLEANUP_REGEX, "").trim();
+        return {
+          emotion,
+          cleanText
+        };
+      }
+      return { cleanText: text };
+    }
+    /**
+     * Check if an emotion is valid
+     * @param emotion Emotion string to validate
+     * @returns True if the emotion is valid
+     */
+    static isValidEmotion(emotion) {
+      return emotions.includes(emotion);
+    }
+    /**
+     * Remove all emotion tags from text
+     * @param text Text containing emotion tags
+     * @returns Clean text without emotion tags
+     */
+    static cleanEmotionTags(text) {
+      return text.replace(EMOTION_TAG_CLEANUP_REGEX, "").trim();
+    }
+    /**
+     * Add emotion tag to text
+     * @param emotion Emotion to add
+     * @param text Text content
+     * @returns Text with emotion tag prepended
+     */
+    static addEmotionTag(emotion, text) {
+      return `[${emotion}] ${text}`;
+    }
+  };
+
+  // src/utils/screenplay.ts
+  function textToScreenplay(text) {
+    const { emotion, cleanText } = EmotionParser.extractEmotion(text);
+    if (emotion) {
+      return {
+        emotion,
+        text: cleanText
+      };
+    }
+    return { text: cleanText };
+  }
+  function textsToScreenplay(texts) {
+    return texts.map((text) => textToScreenplay(text));
+  }
+  function screenplayToText(screenplay) {
+    if (screenplay.emotion) {
+      return EmotionParser.addEmotionTag(screenplay.emotion, screenplay.text);
+    }
+    return screenplay.text;
+  }
+
+  // src/utils/runOnce.ts
+  async function runOnceText(chat, messages) {
+    const { blocks } = await chat.chatOnce(messages, false, () => {
+    });
+    return StreamTextAccumulator.getFullText(blocks);
+  }
+
+  // src/utils/openaiCompatibleSse.ts
+  var parseJsonPayload = (payload, onJsonError) => {
+    try {
+      return JSON.parse(payload);
+    } catch (error) {
+      if (onJsonError) {
+        onJsonError(payload, error);
+        return void 0;
+      }
+      throw error;
+    }
+  };
+  var forEachSsePayload = async (res, onPayload) => {
+    const reader = res.body?.getReader();
+    if (!reader) {
+      throw new Error("Response body is null.");
+    }
+    const dec = new TextDecoder();
+    let buf = "";
+    let shouldStop = false;
+    while (!shouldStop) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += dec.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop() || "";
+      for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith(":")) continue;
+        if (!trimmedLine.startsWith("data:")) continue;
+        const payload = trimmedLine.slice(5).trim();
+        if (payload === "[DONE]") {
+          shouldStop = true;
+          break;
+        }
+        onPayload(payload);
+      }
+    }
+  };
+  async function parseOpenAICompatibleTextStream(res, onPartial, options = {}) {
+    let full = "";
+    await forEachSsePayload(res, (payload) => {
+      const json = parseJsonPayload(payload, options.onJsonError);
+      if (!json) return;
+      const content = json.choices?.[0]?.delta?.content || "";
+      if (content) {
+        onPartial(content);
+        full += content;
+      }
+    });
+    return full;
+  }
+  async function parseOpenAICompatibleToolStream(res, onPartial, options = {}) {
+    const textBlocks = [];
+    const toolCallsMap = /* @__PURE__ */ new Map();
+    const appendTextBlock = options.appendTextBlock ?? StreamTextAccumulator.append;
+    await forEachSsePayload(res, (payload) => {
+      const json = parseJsonPayload(payload, options.onJsonError);
+      if (!json) return;
+      const delta = json.choices?.[0]?.delta;
+      if (delta?.content) {
+        onPartial(delta.content);
+        appendTextBlock(textBlocks, delta.content);
+      }
+      if (delta?.tool_calls) {
+        delta.tool_calls.forEach((c) => {
+          const entry = toolCallsMap.get(c.index) ?? {
+            id: c.id,
+            name: c.function?.name,
+            args: ""
+          };
+          entry.args += c.function?.arguments || "";
+          toolCallsMap.set(c.index, entry);
+        });
+      }
+    });
+    const toolBlocks = Array.from(toolCallsMap.entries()).sort((a, b) => a[0] - b[0]).map(([_, e]) => ({
+      type: "tool_use",
+      id: e.id,
+      name: e.name,
+      input: JSON.parse(e.args || "{}")
+    }));
+    const blocks = [...textBlocks, ...toolBlocks];
+    return {
+      blocks,
+      stop_reason: toolBlocks.length ? "tool_use" : "end"
+    };
+  }
+  function parseOpenAICompatibleOneShot(data) {
+    const choice = data?.choices?.[0];
+    const blocks = [];
+    if (choice?.message?.tool_calls?.length) {
+      choice.message.tool_calls.forEach(
+        (c) => blocks.push({
+          type: "tool_use",
+          id: c.id,
+          name: c.function?.name,
+          input: JSON.parse(c.function?.arguments || "{}")
+        })
+      );
+    } else if (choice?.message?.content) {
+      blocks.push({ type: "text", text: choice.message.content });
+    }
+    return {
+      blocks,
+      stop_reason: choice?.finish_reason === "tool_calls" || blocks.some((b) => b.type === "tool_use") ? "tool_use" : "end"
+    };
+  }
+
+  // src/utils/openaiCompatibleTools.ts
+  var buildOpenAICompatibleTools = (tools, format = "chat-completions") => {
+    if (tools.length === 0) return [];
+    if (format === "responses") {
+      return tools.map((t) => ({
+        type: "function",
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }));
+    }
+    return tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }
+    }));
+  };
+
+  // src/utils/processChatFlow.ts
+  async function processChatWithOptionalTools(options) {
+    if (!options.hasTools) {
+      const full = await options.runWithoutTools();
+      await options.onCompleteResponse(full);
+      return;
+    }
+    const result = await options.runWithTools();
+    if (options.onToolBlocks) {
+      options.onToolBlocks(result.blocks);
+    }
+    if (result.stop_reason === "end") {
+      const full = StreamTextAccumulator.getFullText(
+        result.blocks
+      );
+      await options.onCompleteResponse(full);
+      return;
+    }
+    throw new Error(options.toolErrorMessage);
+  }
+
+  // src/utils/visionModelResolver.ts
+  var resolveVisionModel = (options) => {
+    const baseModel = options.model ?? options.defaultModel;
+    const resolved = options.visionModel ?? (options.supportsVisionForModel(baseModel) ? baseModel : options.defaultVisionModel);
+    if (options.validate === "explicit" && options.visionModel && !options.supportsVisionForModel(options.visionModel)) {
+      throw new Error(
+        `Model ${options.visionModel} does not support vision capabilities.`
+      );
+    }
+    if (options.validate === "resolved" && !options.supportsVisionForModel(resolved)) {
+      throw new Error(`Model ${resolved} does not support vision capabilities.`);
+    }
+    return resolved;
+  };
+
+  // src/services/providers/claude/ClaudeChatService.ts
+  var ClaudeChatService = class {
     /**
      * Constructor
-     * @param apiKey OpenAI API key
+     * @param apiKey Anthropic 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 (optional)
+     * @throws Error if the vision model doesn't support vision capabilities
      */
-    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) {
+    constructor(apiKey, model = MODEL_CLAUDE_3_HAIKU, visionModel = MODEL_CLAUDE_3_HAIKU, tools = [], mcpServers = [], responseLength) {
       /** Provider name */
-      this.provider = "openai";
+      this.provider = "claude";
       this.apiKey = apiKey;
-      this.model = model;
-      this.tools = tools || [];
-      this.endpoint = endpoint;
+      this.model = model || MODEL_CLAUDE_3_HAIKU;
+      this.visionModel = visionModel || MODEL_CLAUDE_3_HAIKU;
+      this.tools = tools;
       this.mcpServers = mcpServers;
       this.responseLength = responseLength;
-      this.verbosity = verbosity;
-      this.reasoning_effort = reasoning_effort;
-      this.enableReasoningSummary = enableReasoningSummary;
-      if (!VISION_SUPPORTED_MODELS.includes(visionModel)) {
+      if (!CLAUDE_VISION_SUPPORTED_MODELS.includes(this.visionModel)) {
         throw new Error(
-          `Model ${visionModel} does not support vision capabilities.`
+          `Model ${this.visionModel} does not support vision capabilities.`
         );
       }
-      this.visionModel = visionModel;
     }
     /**
      * Get the current model name
@@ -569,6 +820,36 @@ If it's in another language, summarize in that language.
     getVisionModel() {
       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);
+    }
+    /**
+     * Remove MCP server by name
+     * @param serverName Name of the server to remove
+     */
+    removeMCPServer(serverName) {
+      this.mcpServers = this.mcpServers.filter(
+        (server) => server.name !== serverName
+      );
+    }
+    /**
+     * Check if MCP servers are configured
+     * @returns True if MCP servers are configured
+     */
+    hasMCPServers() {
+      return this.mcpServers.length > 0;
+    }
     /**
      * Process chat messages
      * @param messages Array of messages to send
@@ -576,582 +857,410 @@ If it's in another language, summarize in that language.
      * @param onCompleteResponse Callback to execute when response is complete
      */
     async processChat(messages, onPartialResponse, onCompleteResponse) {
-      if (this.tools.length === 0) {
-        const res = await this.callOpenAI(messages, this.model, true);
-        const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
-        try {
-          if (isResponsesAPI) {
-            const result = await this.parseResponsesStream(
-              res,
-              onPartialResponse
-            );
-            const full = result.blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-            await onCompleteResponse(full);
-          } else {
-            const full = await this.handleStream(res, onPartialResponse);
-            await onCompleteResponse(full);
-          }
-        } catch (error) {
-          console.error("[processChat] Error in streaming/completion:", error);
-          throw error;
-        }
-        return;
-      }
-      const { blocks, stop_reason } = await this.chatOnce(messages);
-      if (stop_reason === "end") {
-        const full = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-        await onCompleteResponse(full);
-        return;
-      }
-      throw new Error(
-        "processChat received tool_calls. ChatProcessor must use chatOnce() loop when tools are enabled."
-      );
+      await processChatWithOptionalTools({
+        hasTools: this.tools.length > 0 || this.mcpServers.length > 0,
+        runWithoutTools: async () => {
+          const res = await this.callClaude(messages, this.model, true);
+          return this.parsePureStream(res, onPartialResponse);
+        },
+        runWithTools: () => this.chatOnce(messages, true, onPartialResponse),
+        onCompleteResponse,
+        toolErrorMessage: "processChat received tool_calls. ChatProcessor must use chatOnce() loop when tools are enabled."
+      });
     }
     /**
      * 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 {
-        if (this.tools.length === 0) {
-          const res = await this.callOpenAI(messages, this.visionModel, true);
-          const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
-          try {
-            if (isResponsesAPI) {
-              const result = await this.parseResponsesStream(
-                res,
-                onPartialResponse
-              );
-              const full = result.blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-              await onCompleteResponse(full);
-            } else {
-              const full = await this.handleStream(res, onPartialResponse);
-              await onCompleteResponse(full);
-            }
-          } catch (streamError) {
-            console.error(
-              "[processVisionChat] Error in streaming/completion:",
-              streamError
-            );
-            throw streamError;
-          }
-          return;
-        }
-        const { blocks, stop_reason } = await this.visionChatOnce(
-          messages,
-          true,
-          onPartialResponse
-        );
-        if (stop_reason === "end") {
-          const full = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-          await onCompleteResponse(full);
-          return;
-        }
-        throw new Error(
-          "processVisionChat received tool_calls. ChatProcessor must use visionChatOnce() loop when tools are enabled."
-        );
-      } catch (error) {
-        console.error("Error in processVisionChat:", error);
-        throw error;
-      }
-    }
-    /**
-     * 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 ? this.parseResponsesStream(res, onPartialResponse) : this.parseResponsesOneShot(await res.json());
-      }
-      return stream ? this.parseStream(res, onPartialResponse) : this.parseOneShot(await res.json());
-    }
-    async callOpenAI(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}`
+      await processChatWithOptionalTools({
+        hasTools: this.tools.length > 0 || this.mcpServers.length > 0,
+        runWithoutTools: async () => {
+          const res = await this.callClaude(messages, this.visionModel, true);
+          return this.parsePureStream(res, onPartialResponse);
+        },
+        runWithTools: () => this.visionChatOnce(messages),
+        onCompleteResponse,
+        toolErrorMessage: "processVisionChat received tool_calls. ChatProcessor must use chatOnce() loop when tools are enabled."
       });
-      return res;
-    }
-    /**
-     * 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 = {
-        model,
-        stream
-      };
-      const tokenLimit = maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength);
-      if (isResponsesAPI) {
-        body.max_output_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;
     }
     /**
-     * Validate MCP servers compatibility with the current endpoint
+     * Convert AITuber OnAir messages to Claude format
+     * @param messages Array of messages
+     * @returns Claude formatted messages
      */
-    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.`
-        );
-      }
+    convertMessagesToClaudeFormat(messages) {
+      return messages.map((msg) => {
+        return {
+          role: this.mapRoleToClaude(msg.role),
+          content: msg.content
+        };
+      });
     }
     /**
-     * Clean messages for Responses API (remove timestamp and other extra properties)
+     * Convert AITuber OnAir vision messages to Claude format
+     * @param messages Array of vision messages
+     * @returns Claude formatted vision messages
      */
-    cleanMessagesForResponsesAPI(messages) {
+    convertVisionMessagesToClaudeFormat(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 {
+            role: this.mapRoleToClaude(msg.role),
+            content: [
+              {
+                type: "text",
+                text: msg.content
+              }
+            ]
+          };
+        }
+        if (Array.isArray(msg.content)) {
+          const content = msg.content.map((block) => {
+            if (block.type === "image_url") {
+              if (block.image_url.url.startsWith("data:")) {
+                const m = block.image_url.url.match(
+                  /^data:([^;]+);base64,(.+)$/
+                );
+                if (m) {
+                  return {
+                    type: "image",
+                    source: { type: "base64", media_type: m[1], data: m[2] }
+                  };
+                }
+                return null;
+              }
               return {
-                type: "input_image",
-                image_url: block.image_url.url
-                // Extract the URL string directly
+                type: "image",
+                source: {
+                  type: "url",
+                  url: block.image_url.url,
+                  media_type: this.getMimeTypeFromUrl(block.image_url.url)
+                }
               };
             }
             return block;
-          });
-        } else {
-          cleanMsg.content = msg.content;
+          }).filter((b) => b);
+          return {
+            role: this.mapRoleToClaude(msg.role),
+            content
+          };
         }
-        return cleanMsg;
+        return {
+          role: this.mapRoleToClaude(msg.role),
+          content: []
+        };
       });
     }
     /**
-     * Build tools definition based on the endpoint type
+     * Map AITuber OnAir roles to Claude roles
+     * @param role AITuber OnAir role
+     * @returns Claude role
      */
-    buildToolsDefinition() {
-      const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
-      const toolDefs = [];
-      if (this.tools.length > 0) {
-        if (isResponsesAPI) {
-          toolDefs.push(
-            ...this.tools.map((t) => ({
-              type: "function",
-              name: t.name,
-              description: t.description,
-              parameters: t.parameters
-            }))
-          );
-        } else {
-          toolDefs.push(
-            ...this.tools.map((t) => ({
-              type: "function",
-              function: {
-                name: t.name,
-                description: t.description,
-                parameters: t.parameters
-              }
-            }))
-          );
-        }
-      }
-      if (this.mcpServers.length > 0 && isResponsesAPI) {
-        toolDefs.push(...this.buildMCPToolsDefinition());
+    mapRoleToClaude(role) {
+      switch (role) {
+        case "system":
+          return "system";
+        case "user":
+          return "user";
+        case "assistant":
+          return "assistant";
+        default:
+          return "user";
       }
-      return toolDefs;
     }
     /**
-     * Build MCP tools definition for Responses API
+     * Get MIME type from URL
+     * @param url Image URL
+     * @returns MIME type
      */
-    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.tool_configuration?.allowed_tools) {
-          mcpDef.allowed_tools = server.tool_configuration.allowed_tools;
-        }
-        if (server.authorization_token) {
-          mcpDef.headers = {
-            Authorization: `Bearer ${server.authorization_token}`
-          };
-        }
-        return mcpDef;
-      });
+    getMimeTypeFromUrl(url) {
+      const extension = url.split(".").pop()?.toLowerCase();
+      switch (extension) {
+        case "jpg":
+        case "jpeg":
+          return "image/jpeg";
+        case "png":
+          return "image/png";
+        case "gif":
+          return "image/gif";
+        case "webp":
+          return "image/webp";
+        default:
+          return "image/jpeg";
+      }
     }
-    async handleStream(res, onPartial) {
-      const reader = res.body.getReader();
-      const dec = new TextDecoder();
-      let buffer = "";
-      let full = "";
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += dec.decode(value, { stream: true });
-        let idx;
-        while ((idx = buffer.indexOf("\n\n")) !== -1) {
-          const raw = buffer.slice(0, idx).trim();
-          buffer = buffer.slice(idx + 2);
-          if (!raw.startsWith("data:")) continue;
-          const jsonStr = raw.slice(5).trim();
-          if (jsonStr === "[DONE]") {
-            buffer = "";
-            break;
-          }
-          const json = JSON.parse(jsonStr);
-          const content = json.choices[0]?.delta?.content || "";
-          if (content) {
-            onPartial(content);
-            full += content;
-          }
-        }
+    /**
+     * Call Claude API
+     * @param messages Array of messages to send
+     * @param model Model name
+     * @param stream Whether to stream the response
+     * @param maxTokens Maximum tokens for response (optional)
+     * @returns Response
+     */
+    async callClaude(messages, model, stream, maxTokens) {
+      const system = messages.find((m) => m.role === "system")?.content ?? "";
+      const content = messages.filter((m) => m.role !== "system");
+      const hasVision = content.some(
+        (m) => Array.isArray(m.content) && m.content.some(
+          (b) => b.type === "image_url" || b.type === "image"
+        )
+      );
+      const body = {
+        model,
+        system,
+        messages: hasVision ? this.convertVisionMessagesToClaudeFormat(
+          content
+        ) : this.convertMessagesToClaudeFormat(content),
+        stream,
+        max_tokens: maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength)
+      };
+      if (this.tools.length) {
+        body.tools = this.tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          input_schema: t.parameters
+        }));
+        body.tool_choice = { type: "auto" };
+      }
+      if (this.mcpServers.length > 0) {
+        body.mcp_servers = this.mcpServers;
+      }
+      const headers = {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01",
+        "anthropic-dangerous-direct-browser-access": "true"
+      };
+      if (this.mcpServers.length > 0) {
+        headers["anthropic-beta"] = "mcp-client-2025-04-04";
       }
-      return full;
+      const res = await ChatServiceHttpClient.post(
+        ENDPOINT_CLAUDE_API,
+        body,
+        headers
+      );
+      return res;
     }
+    /**
+     * Parse stream response
+     * @param res Response
+     * @param onPartial Callback to receive each part of streaming response
+     * @returns ClaudeInternalCompletion
+     */
     async parseStream(res, onPartial) {
       const reader = res.body.getReader();
       const dec = new TextDecoder();
       const textBlocks = [];
-      const toolCallsMap = /* @__PURE__ */ new Map();
+      const toolCalls = /* @__PURE__ */ new Map();
       let buf = "";
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
         buf += dec.decode(value, { stream: true });
-        let sep;
-        while ((sep = buf.indexOf("\n\n")) !== -1) {
-          const raw = buf.slice(0, sep).trim();
-          buf = buf.slice(sep + 2);
-          if (!raw.startsWith("data:")) continue;
-          const payload = raw.slice(5).trim();
-          if (payload === "[DONE]") {
-            buf = "";
-            break;
-          }
-          const json = JSON.parse(payload);
-          const delta = json.choices[0].delta;
-          if (delta.content) {
-            onPartial(delta.content);
-            textBlocks.push({ type: "text", text: delta.content });
+        let nl;
+        while ((nl = buf.indexOf("\n")) !== -1) {
+          const line = buf.slice(0, nl).trim();
+          buf = buf.slice(nl + 1);
+          if (!line.startsWith("data:")) continue;
+          const payload = line.slice(5).trim();
+          if (payload === "[DONE]") break;
+          const ev = JSON.parse(payload);
+          if (ev.type === "content_block_delta" && ev.delta?.text) {
+            onPartial(ev.delta.text);
+            textBlocks.push({ type: "text", text: ev.delta.text });
           }
-          if (delta.tool_calls) {
-            delta.tool_calls.forEach((c) => {
-              const entry = toolCallsMap.get(c.index) ?? {
-                id: c.id,
-                name: c.function.name,
-                args: ""
-              };
-              entry.args += c.function.arguments || "";
-              toolCallsMap.set(c.index, entry);
+          if (ev.type === "content_block_start" && ev.content_block?.type === "tool_use") {
+            toolCalls.set(ev.index, {
+              id: ev.content_block.id,
+              name: ev.content_block.name,
+              args: ""
+            });
+          } else if (ev.type === "content_block_start" && ev.content_block?.type === "mcp_tool_use") {
+            toolCalls.set(ev.index, {
+              id: ev.content_block.id,
+              name: ev.content_block.name,
+              args: "",
+              server_name: ev.content_block.server_name
+            });
+          } else if (ev.type === "content_block_start" && // case of non-stream
+          ev.content_block?.type === "tool_result") {
+            textBlocks.push({
+              type: "tool_result",
+              tool_use_id: ev.content_block.tool_use_id,
+              content: ev.content_block.content ?? ""
+            });
+          } else if (ev.type === "content_block_start" && ev.content_block?.type === "mcp_tool_result") {
+            textBlocks.push({
+              type: "mcp_tool_result",
+              tool_use_id: ev.content_block.tool_use_id,
+              is_error: ev.content_block.is_error ?? false,
+              content: ev.content_block.content ?? []
             });
           }
+          if (ev.type === "content_block_delta" && ev.delta?.type === "input_json_delta") {
+            const entry = toolCalls.get(ev.index);
+            if (entry) entry.args += ev.delta.partial_json || "";
+          }
+          if (ev.type === "content_block_stop" && toolCalls.has(ev.index)) {
+            const { id, name, args, server_name } = toolCalls.get(ev.index);
+            if (server_name) {
+              textBlocks.push({
+                type: "mcp_tool_use",
+                id,
+                name,
+                server_name,
+                input: JSON.parse(args || "{}")
+              });
+            } else {
+              textBlocks.push({
+                type: "tool_use",
+                id,
+                name,
+                input: JSON.parse(args || "{}")
+              });
+            }
+            toolCalls.delete(ev.index);
+          }
         }
       }
-      const toolBlocks = Array.from(toolCallsMap.entries()).sort((a, b) => a[0] - b[0]).map(([_, e]) => ({
-        type: "tool_use",
-        id: e.id,
-        name: e.name,
-        input: JSON.parse(e.args || "{}")
-      }));
-      const blocks = [...textBlocks, ...toolBlocks];
       return {
-        blocks,
-        stop_reason: toolBlocks.length ? "tool_use" : "end"
+        blocks: textBlocks,
+        stop_reason: textBlocks.some(
+          (b) => b.type === "tool_use" || b.type === "mcp_tool_use"
+        ) ? "tool_use" : "end"
       };
     }
+    async parsePureStream(res, onPartial) {
+      const { blocks } = await this.parseStream(res, onPartial);
+      return blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
+    }
     parseOneShot(data) {
-      const choice = data.choices[0];
       const blocks = [];
-      if (choice.finish_reason === "tool_calls") {
-        choice.message.tool_calls.forEach(
-          (c) => blocks.push({
+      (data.content ?? []).forEach((c) => {
+        if (c.type === "text") {
+          blocks.push({ type: "text", text: c.text });
+        } else if (c.type === "tool_use") {
+          blocks.push({
             type: "tool_use",
             id: c.id,
-            name: c.function.name,
-            input: JSON.parse(c.function.arguments || "{}")
-          })
-        );
-      } else {
-        blocks.push({ type: "text", text: choice.message.content });
-      }
+            name: c.name,
+            input: c.input ?? {}
+          });
+        } else if (c.type === "mcp_tool_use") {
+          blocks.push({
+            type: "mcp_tool_use",
+            id: c.id,
+            name: c.name,
+            server_name: c.server_name,
+            input: c.input ?? {}
+          });
+        } else if (c.type === "tool_result") {
+          blocks.push({
+            type: "tool_result",
+            tool_use_id: c.tool_use_id,
+            content: c.content ?? ""
+          });
+        } else if (c.type === "mcp_tool_result") {
+          blocks.push({
+            type: "mcp_tool_result",
+            tool_use_id: c.tool_use_id,
+            is_error: c.is_error ?? false,
+            content: c.content ?? []
+          });
+        }
+      });
       return {
         blocks,
-        stop_reason: choice.finish_reason === "tool_calls" ? "tool_use" : "end"
+        stop_reason: blocks.some(
+          (b) => b.type === "tool_use" || b.type === "mcp_tool_use"
+        ) ? "tool_use" : "end"
       };
     }
     /**
-     * Parse streaming response from Responses API (SSE format)
+     * Process chat messages
+     * @param messages Array of messages to send
+     * @param stream Whether to stream the response
+     * @param onPartial Callback to receive each part of streaming response
+     * @param maxTokens Maximum tokens for response (optional)
+     * @returns ToolChatCompletion
      */
-    async parseResponsesStream(res, onPartial) {
-      const reader = res.body.getReader();
-      const dec = new TextDecoder();
-      const textBlocks = [];
-      const toolCallsMap = /* @__PURE__ */ new Map();
-      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);
-              const completionResult = this.handleResponsesSSEEvent(
-                eventType,
-                json,
-                onPartial,
-                textBlocks,
-                toolCallsMap
-              );
-              if (completionResult === "completed") {
-              }
-            } catch (e) {
-              console.warn("Failed to parse SSE data:", eventData);
-            }
-            eventType = "";
-            eventData = "";
-          }
-        }
-      }
-      const toolBlocks = Array.from(toolCallsMap.values()).map(
-        (tool) => ({
-          type: "tool_use",
-          id: tool.id,
-          name: tool.name,
-          input: tool.input || {}
-        })
-      );
-      const blocks = [...textBlocks, ...toolBlocks];
-      return {
-        blocks,
-        stop_reason: toolBlocks.length ? "tool_use" : "end"
-      };
+    async chatOnce(messages, stream = true, onPartial = () => {
+    }, maxTokens) {
+      const res = await this.callClaude(messages, this.model, stream, maxTokens);
+      const internalResult = stream ? await this.parseStream(res, onPartial) : this.parseOneShot(await res.json());
+      return this.convertToStandardCompletion(internalResult);
     }
     /**
-     * Handle specific SSE events from Responses API
-     * @returns 'completed' if the response is completed, undefined otherwise
+     * Process vision chat messages
+     * @param messages Array of messages to send
+     * @param stream Whether to stream the response
+     * @param onPartial Callback to receive each part of streaming response
+     * @param maxTokens Maximum tokens for response (optional)
+     * @returns ToolChatCompletion
      */
-    handleResponsesSSEEvent(eventType, data, onPartial, textBlocks, toolCallsMap) {
-      switch (eventType) {
-        // Item addition events
-        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;
-        // Initial content part events
-        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;
-        // Text delta events
-        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;
-        // Text completion events - do not add text here as it's already accumulated via delta events
-        case "response.output_text.done":
-        case "response.content_part.done":
-          break;
-        // Response completion events
-        case "response.completed":
-          return "completed";
-        // GPT-5 reasoning token events (not visible but counted for billing)
-        case "response.reasoning.started":
-        case "response.reasoning.delta":
-        case "response.reasoning.done":
-          break;
-        default:
-          break;
-      }
-      return void 0;
+    async visionChatOnce(messages, stream = false, onPartial = () => {
+    }, maxTokens) {
+      const res = await this.callClaude(
+        messages,
+        this.visionModel,
+        stream,
+        maxTokens
+      );
+      const internalResult = stream ? await this.parseStream(res, onPartial) : this.parseOneShot(await res.json());
+      return this.convertToStandardCompletion(internalResult);
     }
     /**
-     * Parse non-streaming response from Responses API
+     * Convert internal completion to standard ToolChatCompletion
+     * @param completion Internal completion result
+     * @returns Standard ToolChatCompletion
      */
-    parseResponsesOneShot(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) : {}
-            });
-          }
-        });
-      }
+    convertToStandardCompletion(completion) {
+      const standardBlocks = completion.blocks.filter(
+        (block) => {
+          return block.type === "text" || block.type === "tool_use" || block.type === "tool_result";
+        }
+      );
       return {
-        blocks,
-        stop_reason: blocks.some((b) => b.type === "tool_use") ? "tool_use" : "end"
+        blocks: standardBlocks,
+        stop_reason: completion.stop_reason
       };
     }
   };
 
-  // src/services/providers/openai/OpenAIChatServiceProvider.ts
-  var OpenAIChatServiceProvider = class {
+  // src/services/providers/claude/ClaudeChatServiceProvider.ts
+  var ClaudeChatServiceProvider = class {
     /**
      * Create a chat service instance
-     * @param options Service options
-     * @returns OpenAIChatService instance
+     * @param options Service options (can include mcpServers)
+     * @returns ClaudeChatService instance
      */
     createChatService(options) {
-      const optimizedOptions = this.optimizeGPT5Options(options);
-      const visionModel = optimizedOptions.visionModel || (this.supportsVisionForModel(
-        optimizedOptions.model || this.getDefaultModel()
-      ) ? optimizedOptions.model : this.getDefaultModel());
-      const tools = optimizedOptions.tools;
-      const mcpServers = optimizedOptions.mcpServers ?? [];
-      const modelName = optimizedOptions.model || this.getDefaultModel();
-      let shouldUseResponsesAPI = false;
-      if (mcpServers.length > 0) {
-        shouldUseResponsesAPI = true;
-      } else if (isGPT5Model(modelName)) {
-        const preference = optimizedOptions.gpt5EndpointPreference || "chat";
-        shouldUseResponsesAPI = preference === "responses";
-      }
-      const endpoint = optimizedOptions.endpoint || (shouldUseResponsesAPI ? ENDPOINT_OPENAI_RESPONSES_API : ENDPOINT_OPENAI_CHAT_COMPLETIONS_API);
-      return new OpenAIChatService(
-        optimizedOptions.apiKey,
-        modelName,
+      const visionModel = resolveVisionModel({
+        model: options.model,
+        visionModel: options.visionModel,
+        defaultModel: this.getDefaultModel(),
+        defaultVisionModel: this.getDefaultModel(),
+        supportsVisionForModel: (model) => this.supportsVisionForModel(model),
+        validate: "resolved"
+      });
+      return new ClaudeChatService(
+        options.apiKey,
+        options.model || this.getDefaultModel(),
         visionModel,
-        tools,
-        endpoint,
-        mcpServers,
-        optimizedOptions.responseLength,
-        optimizedOptions.verbosity,
-        optimizedOptions.reasoning_effort,
-        optimizedOptions.enableReasoningSummary
+        options.tools ?? [],
+        options.mcpServers ?? [],
+        options.responseLength
       );
     }
     /**
      * Get the provider name
-     * @returns Provider name ('openai')
+     * @returns Provider name ('claude')
      */
     getProviderName() {
-      return "openai";
+      return "claude";
     }
     /**
      * Get the list of supported models
@@ -1159,19 +1268,16 @@ If it's in another language, summarize in that language.
      */
     getSupportedModels() {
       return [
-        MODEL_GPT_5_NANO,
-        MODEL_GPT_5_MINI,
-        MODEL_GPT_5,
-        MODEL_GPT_5_1,
-        MODEL_GPT_4_1,
-        MODEL_GPT_4_1_MINI,
-        MODEL_GPT_4_1_NANO,
-        MODEL_GPT_4O_MINI,
-        MODEL_GPT_4O,
-        MODEL_O3_MINI,
-        MODEL_O1_MINI,
-        MODEL_O1,
-        MODEL_GPT_4_5_PREVIEW
+        MODEL_CLAUDE_3_HAIKU,
+        MODEL_CLAUDE_3_5_HAIKU,
+        MODEL_CLAUDE_3_5_SONNET,
+        MODEL_CLAUDE_3_7_SONNET,
+        MODEL_CLAUDE_4_SONNET,
+        MODEL_CLAUDE_4_OPUS,
+        MODEL_CLAUDE_4_5_SONNET,
+        MODEL_CLAUDE_4_5_HAIKU,
+        MODEL_CLAUDE_4_5_OPUS,
+        MODEL_CLAUDE_4_6_OPUS
       ];
     }
     /**
@@ -1179,7 +1285,7 @@ If it's in another language, summarize in that language.
      * @returns Default model name
      */
     getDefaultModel() {
-      return MODEL_GPT_5_NANO;
+      return MODEL_CLAUDE_3_HAIKU;
     }
     /**
      * Check if this provider supports vision (image processing)
@@ -1194,55 +1300,7 @@ If it's in another language, summarize in that language.
      * @returns True if the model supports vision, false otherwise
      */
     supportsVisionForModel(model) {
-      return VISION_SUPPORTED_MODELS.includes(model);
-    }
-    /**
-     * Apply GPT-5 specific optimizations to options
-     * @param options Original chat service options
-     * @returns Optimized options for GPT-5 usage
-     */
-    optimizeGPT5Options(options) {
-      const modelName = options.model || this.getDefaultModel();
-      if (!isGPT5Model(modelName)) {
-        return options;
-      }
-      const optimized = { ...options };
-      if (options.gpt5Preset) {
-        const preset = GPT5_PRESETS[options.gpt5Preset];
-        optimized.reasoning_effort = preset.reasoning_effort;
-        optimized.verbosity = preset.verbosity;
-      } else {
-        if (!options.reasoning_effort) {
-          optimized.reasoning_effort = this.getDefaultReasoningEffortForModel(modelName);
-        }
-      }
-      optimized.reasoning_effort = this.normalizeReasoningEffort(
-        modelName,
-        optimized.reasoning_effort
-      );
-      return optimized;
-    }
-    /**
-     * Determine the default reasoning effort for GPT-5 family models
-     * GPT-5.1 defaults to 'none' (fastest), earlier GPT-5 defaults to 'medium'
-     */
-    getDefaultReasoningEffortForModel(modelName) {
-      if (modelName === MODEL_GPT_5_1) {
-        return "none";
-      }
-      return "medium";
-    }
-    normalizeReasoningEffort(modelName, effort) {
-      if (!effort) {
-        return void 0;
-      }
-      if (effort === "none" && !allowsReasoningNone(modelName)) {
-        return this.getDefaultReasoningEffortForModel(modelName);
-      }
-      if (effort === "minimal" && !allowsReasoningMinimal(modelName)) {
-        return "none";
-      }
-      return effort;
+      return CLAUDE_VISION_SUPPORTED_MODELS.includes(model);
     }
   };
 
@@ -1495,26 +1553,17 @@ If it's in another language, summarize in that language.
      */
     async processChat(messages, onPartialResponse, onCompleteResponse) {
       try {
-        if (this.tools.length === 0 && this.mcpServers.length === 0) {
-          const res = await this.callGemini(messages, this.model, true);
-          const { blocks: blocks2 } = await this.parseStream(res, onPartialResponse);
-          const full = blocks2.filter((b) => b.type === "text").map((b) => b.text).join("");
-          await onCompleteResponse(full);
-          return;
-        }
-        const { blocks, stop_reason } = await this.chatOnce(
-          messages,
-          true,
-          onPartialResponse
-        );
-        if (stop_reason === "end") {
-          const full = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-          await onCompleteResponse(full);
-          return;
-        }
-        throw new Error(
-          "Received functionCall. Use chatOnce() loop when tools are enabled."
-        );
+        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);
+            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;
@@ -1522,23 +1571,22 @@ If it's in another language, summarize in that language.
     }
     async processVisionChat(messages, onPartialResponse, onCompleteResponse) {
       try {
-        if (this.tools.length === 0 && this.mcpServers.length === 0) {
-          const res = await this.callGemini(messages, this.visionModel, true);
-          const { blocks: blocks2 } = await this.parseStream(res, onPartialResponse);
-          const full = blocks2.filter((b) => b.type === "text").map((b) => b.text).join("");
-          await onCompleteResponse(full);
-          return;
-        }
-        const { blocks, stop_reason } = await this.visionChatOnce(messages);
-        blocks.filter((b) => b.type === "text").forEach((b) => onPartialResponse(b.text));
-        if (stop_reason === "end") {
-          const full = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-          await onCompleteResponse(full);
-          return;
-        }
-        throw new Error(
-          "Received functionCall. Use visionChatOnce() loop when tools are enabled."
-        );
+        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);
+            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;
@@ -1943,7 +1991,14 @@ If it's in another language, summarize in that language.
      * @returns GeminiChatService instance
      */
     createChatService(options) {
-      const visionModel = options.visionModel || (this.supportsVisionForModel(options.model || this.getDefaultModel()) ? options.model : this.getDefaultModel());
+      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(
         options.apiKey,
         options.model || this.getDefaultModel(),
@@ -1998,563 +2053,281 @@ If it's in another language, summarize in that language.
     }
   };
 
-  // src/services/providers/claude/ClaudeChatService.ts
-  var ClaudeChatService = class {
+  // src/services/providers/kimi/KimiChatService.ts
+  var KimiChatService = class {
     /**
      * Constructor
-     * @param apiKey Anthropic API key
+     * @param apiKey Kimi 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 (optional)
-     * @throws Error if the vision model doesn't support vision capabilities
      */
-    constructor(apiKey, model = MODEL_CLAUDE_3_HAIKU, visionModel = MODEL_CLAUDE_3_HAIKU, tools = [], mcpServers = [], responseLength) {
+    constructor(apiKey, model = MODEL_KIMI_K2_5, visionModel = MODEL_KIMI_K2_5, tools, endpoint = ENDPOINT_KIMI_CHAT_COMPLETIONS_API, responseLength, responseFormat, thinking) {
       /** Provider name */
-      this.provider = "claude";
+      this.provider = "kimi";
       this.apiKey = apiKey;
-      this.model = model || MODEL_CLAUDE_3_HAIKU;
-      this.visionModel = visionModel || MODEL_CLAUDE_3_HAIKU;
-      this.tools = tools;
-      this.mcpServers = mcpServers;
+      this.model = model;
+      this.tools = tools || [];
+      this.endpoint = endpoint;
       this.responseLength = responseLength;
-      if (!CLAUDE_VISION_SUPPORTED_MODELS.includes(this.visionModel)) {
-        throw new Error(
-          `Model ${this.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;
     }
-    /**
-     * 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);
-    }
-    /**
-     * Remove MCP server by name
-     * @param serverName Name of the server to remove
-     */
-    removeMCPServer(serverName) {
-      this.mcpServers = this.mcpServers.filter(
-        (server) => server.name !== serverName
-      );
-    }
-    /**
-     * Check if MCP servers are configured
-     * @returns True if MCP servers are configured
-     */
-    hasMCPServers() {
-      return this.mcpServers.length > 0;
-    }
     /**
      * 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) {
-      if (this.tools.length === 0 && this.mcpServers.length === 0) {
-        const res = await this.callClaude(messages, this.model, true);
-        const full = await this.parsePureStream(res, onPartialResponse);
-        await onCompleteResponse(full);
-        return;
-      }
-      const result = await this.chatOnce(messages, true, onPartialResponse);
-      if (result.stop_reason === "end") {
-        const full = result.blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-        await onCompleteResponse(full);
-        return;
-      }
-      throw new Error(
-        "processChat received tool_calls. ChatProcessor must use chatOnce() loop when tools are enabled."
-      );
+      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."
+      });
     }
     /**
      * 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
      */
     async processVisionChat(messages, onPartialResponse, onCompleteResponse) {
-      if (this.tools.length === 0 && this.mcpServers.length === 0) {
-        const res = await this.callClaude(messages, this.visionModel, true);
-        const full = await this.parsePureStream(res, onPartialResponse);
-        await onCompleteResponse(full);
-        return;
-      }
-      const result = await this.visionChatOnce(messages);
-      if (result.stop_reason === "end") {
-        const full = result.blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-        await onCompleteResponse(full);
-        return;
+      if (!isKimiVisionModel(this.visionModel)) {
+        throw new Error(
+          `Model ${this.visionModel} does not support vision capabilities.`
+        );
       }
-      throw new Error(
-        "processVisionChat received tool_calls. ChatProcessor must use chatOnce() loop when tools are enabled."
-      );
-    }
-    /**
-     * Convert AITuber OnAir messages to Claude format
-     * @param messages Array of messages
-     * @returns Claude formatted messages
-     */
-    convertMessagesToClaudeFormat(messages) {
-      return messages.map((msg) => {
-        return {
-          role: this.mapRoleToClaude(msg.role),
-          content: msg.content
-        };
+      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."
       });
     }
     /**
-     * Convert AITuber OnAir vision messages to Claude format
-     * @param messages Array of vision messages
-     * @returns Claude formatted vision messages
+     * Process chat messages with tools (text only)
      */
-    convertVisionMessagesToClaudeFormat(messages) {
-      return messages.map((msg) => {
-        if (typeof msg.content === "string") {
-          return {
-            role: this.mapRoleToClaude(msg.role),
-            content: [
-              {
-                type: "text",
-                text: msg.content
-              }
-            ]
-          };
-        }
-        if (Array.isArray(msg.content)) {
-          const content = msg.content.map((block) => {
-            if (block.type === "image_url") {
-              if (block.image_url.url.startsWith("data:")) {
-                const m = block.image_url.url.match(
-                  /^data:([^;]+);base64,(.+)$/
-                );
-                if (m) {
-                  return {
-                    type: "image",
-                    source: { type: "base64", media_type: m[1], data: m[2] }
-                  };
-                }
-                return null;
-              }
-              return {
-                type: "image",
-                source: {
-                  type: "url",
-                  url: block.image_url.url,
-                  media_type: this.getMimeTypeFromUrl(block.image_url.url)
-                }
-              };
-            }
-            return block;
-          }).filter((b) => b);
-          return {
-            role: this.mapRoleToClaude(msg.role),
-            content
-          };
-        }
-        return {
-          role: this.mapRoleToClaude(msg.role),
-          content: []
-        };
-      });
+    async chatOnce(messages, stream = true, onPartialResponse = () => {
+    }, maxTokens) {
+      const res = await this.callKimi(messages, this.model, stream, maxTokens);
+      return this.parseResponse(res, stream, onPartialResponse);
     }
     /**
-     * Map AITuber OnAir roles to Claude roles
-     * @param role AITuber OnAir role
-     * @returns Claude role
+     * Process vision chat messages with tools
      */
-    mapRoleToClaude(role) {
-      switch (role) {
-        case "system":
-          return "system";
-        case "user":
-          return "user";
-        case "assistant":
-          return "assistant";
-        default:
-          return "user";
+    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(
+        messages,
+        this.visionModel,
+        stream,
+        maxTokens
+      );
+      return this.parseResponse(res, stream, onPartialResponse);
     }
-    /**
-     * Get MIME type from URL
-     * @param url Image URL
-     * @returns MIME type
-     */
-    getMimeTypeFromUrl(url) {
-      const extension = url.split(".").pop()?.toLowerCase();
-      switch (extension) {
-        case "jpg":
-        case "jpeg":
-          return "image/jpeg";
-        case "png":
-          return "image/png";
-        case "gif":
-          return "image/gif";
-        case "webp":
-          return "image/webp";
-        default:
-          return "image/jpeg";
-      }
+    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;
     }
     /**
-     * Call Claude API
-     * @param messages Array of messages to send
-     * @param model Model name
-     * @param stream Whether to stream the response
-     * @param maxTokens Maximum tokens for response (optional)
-     * @returns Response
+     * Build request body (OpenAI-compatible Chat Completions)
      */
-    async callClaude(messages, model, stream, maxTokens) {
-      const system = messages.find((m) => m.role === "system")?.content ?? "";
-      const content = messages.filter((m) => m.role !== "system");
-      const hasVision = content.some(
-        (m) => Array.isArray(m.content) && m.content.some(
-          (b) => b.type === "image_url" || b.type === "image"
-        )
-      );
+    buildRequestBody(messages, model, stream, maxTokens) {
       const body = {
         model,
-        system,
-        messages: hasVision ? this.convertVisionMessagesToClaudeFormat(
-          content
-        ) : this.convertMessagesToClaudeFormat(content),
         stream,
-        max_tokens: maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength)
+        messages
       };
-      if (this.tools.length) {
-        body.tools = this.tools.map((t) => ({
-          name: t.name,
-          description: t.description,
-          input_schema: t.parameters
-        }));
-        body.tool_choice = { type: "auto" };
-      }
-      if (this.mcpServers.length > 0) {
-        body.mcp_servers = this.mcpServers;
+      const tokenLimit = maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength);
+      if (tokenLimit !== void 0) {
+        body.max_tokens = tokenLimit;
       }
-      const headers = {
-        "Content-Type": "application/json",
-        "x-api-key": this.apiKey,
-        "anthropic-version": "2023-06-01",
-        "anthropic-dangerous-direct-browser-access": "true"
-      };
-      if (this.mcpServers.length > 0) {
-        headers["anthropic-beta"] = "mcp-client-2025-04-04";
+      if (this.responseFormat) {
+        body.response_format = this.responseFormat;
       }
-      const res = await ChatServiceHttpClient.post(
-        ENDPOINT_CLAUDE_API,
-        body,
-        headers
-      );
-      return res;
-    }
-    /**
-     * Parse stream response
-     * @param res Response
-     * @param onPartial Callback to receive each part of streaming response
-     * @returns ClaudeInternalCompletion
-     */
-    async parseStream(res, onPartial) {
-      const reader = res.body.getReader();
-      const dec = new TextDecoder();
-      const textBlocks = [];
-      const toolCalls = /* @__PURE__ */ new Map();
-      let buf = "";
-      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) {
-          const line = buf.slice(0, nl).trim();
-          buf = buf.slice(nl + 1);
-          if (!line.startsWith("data:")) continue;
-          const payload = line.slice(5).trim();
-          if (payload === "[DONE]") break;
-          const ev = JSON.parse(payload);
-          if (ev.type === "content_block_delta" && ev.delta?.text) {
-            onPartial(ev.delta.text);
-            textBlocks.push({ type: "text", text: ev.delta.text });
-          }
-          if (ev.type === "content_block_start" && ev.content_block?.type === "tool_use") {
-            toolCalls.set(ev.index, {
-              id: ev.content_block.id,
-              name: ev.content_block.name,
-              args: ""
-            });
-          } else if (ev.type === "content_block_start" && ev.content_block?.type === "mcp_tool_use") {
-            toolCalls.set(ev.index, {
-              id: ev.content_block.id,
-              name: ev.content_block.name,
-              args: "",
-              server_name: ev.content_block.server_name
-            });
-          } else if (ev.type === "content_block_start" && // case of non-stream
-          ev.content_block?.type === "tool_result") {
-            textBlocks.push({
-              type: "tool_result",
-              tool_use_id: ev.content_block.tool_use_id,
-              content: ev.content_block.content ?? ""
-            });
-          } else if (ev.type === "content_block_start" && ev.content_block?.type === "mcp_tool_result") {
-            textBlocks.push({
-              type: "mcp_tool_result",
-              tool_use_id: ev.content_block.tool_use_id,
-              is_error: ev.content_block.is_error ?? false,
-              content: ev.content_block.content ?? []
-            });
-          }
-          if (ev.type === "content_block_delta" && ev.delta?.type === "input_json_delta") {
-            const entry = toolCalls.get(ev.index);
-            if (entry) entry.args += ev.delta.partial_json || "";
-          }
-          if (ev.type === "content_block_stop" && toolCalls.has(ev.index)) {
-            const { id, name, args, server_name } = toolCalls.get(ev.index);
-            if (server_name) {
-              textBlocks.push({
-                type: "mcp_tool_use",
-                id,
-                name,
-                server_name,
-                input: JSON.parse(args || "{}")
-              });
-            } else {
-              textBlocks.push({
-                type: "tool_use",
-                id,
-                name,
-                input: JSON.parse(args || "{}")
-              });
-            }
-            toolCalls.delete(ev.index);
+      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;
         }
       }
-      return {
-        blocks: textBlocks,
-        stop_reason: textBlocks.some(
-          (b) => b.type === "tool_use" || b.type === "mcp_tool_use"
-        ) ? "tool_use" : "end"
-      };
-    }
-    async parsePureStream(res, onPartial) {
-      const { blocks } = await this.parseStream(res, onPartial);
-      return blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-    }
-    parseOneShot(data) {
-      const blocks = [];
-      (data.content ?? []).forEach((c) => {
-        if (c.type === "text") {
-          blocks.push({ type: "text", text: c.text });
-        } else if (c.type === "tool_use") {
-          blocks.push({
-            type: "tool_use",
-            id: c.id,
-            name: c.name,
-            input: c.input ?? {}
-          });
-        } else if (c.type === "mcp_tool_use") {
-          blocks.push({
-            type: "mcp_tool_use",
-            id: c.id,
-            name: c.name,
-            server_name: c.server_name,
-            input: c.input ?? {}
-          });
-        } else if (c.type === "tool_result") {
-          blocks.push({
-            type: "tool_result",
-            tool_use_id: c.tool_use_id,
-            content: c.content ?? ""
-          });
-        } else if (c.type === "mcp_tool_result") {
-          blocks.push({
-            type: "mcp_tool_result",
-            tool_use_id: c.tool_use_id,
-            is_error: c.is_error ?? false,
-            content: c.content ?? []
-          });
-        }
-      });
-      return {
-        blocks,
-        stop_reason: blocks.some(
-          (b) => b.type === "tool_use" || b.type === "mcp_tool_use"
-        ) ? "tool_use" : "end"
-      };
-    }
-    /**
-     * Process chat messages
-     * @param messages Array of messages to send
-     * @param stream Whether to stream the response
-     * @param onPartial Callback to receive each part of streaming response
-     * @param maxTokens Maximum tokens for response (optional)
-     * @returns ToolChatCompletion
-     */
-    async chatOnce(messages, stream = true, onPartial = () => {
-    }, maxTokens) {
-      const res = await this.callClaude(messages, this.model, stream, maxTokens);
-      const internalResult = stream ? await this.parseStream(res, onPartial) : this.parseOneShot(await res.json());
-      return this.convertToStandardCompletion(internalResult);
+      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)
+      });
     }
     /**
-     * Process vision chat messages
-     * @param messages Array of messages to send
-     * @param stream Whether to stream the response
-     * @param onPartial Callback to receive each part of streaming response
-     * @param maxTokens Maximum tokens for response (optional)
-     * @returns ToolChatCompletion
+     * Parse streaming response with tool support
      */
-    async visionChatOnce(messages, stream = false, onPartial = () => {
-    }, maxTokens) {
-      const res = await this.callClaude(
-        messages,
-        this.visionModel,
-        stream,
-        maxTokens
-      );
-      const internalResult = stream ? await this.parseStream(res, onPartial) : this.parseOneShot(await res.json());
-      return this.convertToStandardCompletion(internalResult);
+    async parseStream(res, onPartial) {
+      return parseOpenAICompatibleToolStream(res, onPartial, {
+        onJsonError: (payload) => console.debug("Failed to parse SSE data:", payload)
+      });
     }
     /**
-     * Convert internal completion to standard ToolChatCompletion
-     * @param completion Internal completion result
-     * @returns Standard ToolChatCompletion
+     * Parse non-streaming response
      */
-    convertToStandardCompletion(completion) {
-      const standardBlocks = completion.blocks.filter(
-        (block) => {
-          return block.type === "text" || block.type === "tool_use" || block.type === "tool_result";
-        }
-      );
-      return {
-        blocks: standardBlocks,
-        stop_reason: completion.stop_reason
-      };
+    parseOneShot(data) {
+      return parseOpenAICompatibleOneShot(data);
     }
   };
 
-  // src/services/providers/claude/ClaudeChatServiceProvider.ts
-  var ClaudeChatServiceProvider = class {
+  // src/services/providers/kimi/KimiChatServiceProvider.ts
+  var KimiChatServiceProvider = class {
     /**
      * Create a chat service instance
-     * @param options Service options (can include mcpServers)
-     * @returns ClaudeChatService instance
      */
     createChatService(options) {
-      const visionModel = options.visionModel || (this.supportsVisionForModel(options.model || this.getDefaultModel()) ? options.model : this.getDefaultModel());
-      return new ClaudeChatService(
+      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,
-        options.model || this.getDefaultModel(),
+        model,
         visionModel,
-        options.tools ?? [],
-        options.mcpServers ?? [],
-        options.responseLength
+        tools,
+        endpoint,
+        options.responseLength,
+        options.responseFormat,
+        thinking
       );
     }
     /**
      * Get the provider name
-     * @returns Provider name ('claude')
      */
     getProviderName() {
-      return "claude";
+      return "kimi";
     }
     /**
      * Get the list of supported models
-     * @returns Array of supported model names
      */
     getSupportedModels() {
-      return [
-        MODEL_CLAUDE_3_HAIKU,
-        MODEL_CLAUDE_3_5_HAIKU,
-        MODEL_CLAUDE_3_5_SONNET,
-        MODEL_CLAUDE_3_7_SONNET,
-        MODEL_CLAUDE_4_SONNET,
-        MODEL_CLAUDE_4_OPUS,
-        MODEL_CLAUDE_4_5_SONNET,
-        MODEL_CLAUDE_4_5_HAIKU,
-        MODEL_CLAUDE_4_5_OPUS
-      ];
+      return [MODEL_KIMI_K2_5];
     }
     /**
      * Get the default model
-     * @returns Default model name
      */
     getDefaultModel() {
-      return MODEL_CLAUDE_3_HAIKU;
+      return MODEL_KIMI_K2_5;
     }
     /**
-     * Check if this provider supports vision (image processing)
-     * @returns Vision support status (true)
+     * Get the default vision model
+     */
+    getDefaultVisionModel() {
+      return MODEL_KIMI_K2_5;
+    }
+    /**
+     * Check if this provider supports vision
      */
     supportsVision() {
       return true;
     }
     /**
      * 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 CLAUDE_VISION_SUPPORTED_MODELS.includes(model);
+      return isKimiVisionModel(model);
+    }
+    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 `${baseUrl}/chat/completions`;
+      }
+      return ENDPOINT_KIMI_CHAT_COMPLETIONS_API;
+    }
+    normalizeEndpoint(value) {
+      return value.replace(/\/+$/, "");
     }
   };
 
-  // src/services/providers/openrouter/OpenRouterChatService.ts
-  var OpenRouterChatService = class {
+  // src/services/providers/openai/OpenAIChatService.ts
+  var OpenAIChatService = class {
     /**
      * Constructor
-     * @param apiKey OpenRouter API key
+     * @param apiKey OpenAI API key
      * @param model Name of the model to use
      * @param visionModel Name of the vision model
-     * @param tools Tool definitions (optional)
-     * @param endpoint API endpoint (optional)
-     * @param responseLength Response length configuration (optional)
-     * @param appName Application name for OpenRouter analytics (optional)
-     * @param appUrl Application URL for OpenRouter analytics (optional)
-     * @param reasoning_effort Reasoning effort level (optional)
-     * @param includeReasoning Whether to include reasoning in response (optional)
-     * @param reasoningMaxTokens Maximum tokens for reasoning (optional)
      */
-    constructor(apiKey, model = MODEL_GPT_OSS_20B_FREE, visionModel = MODEL_GPT_OSS_20B_FREE, tools, endpoint = ENDPOINT_OPENROUTER_API, responseLength, appName, appUrl, reasoning_effort, includeReasoning, reasoningMaxTokens) {
+    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 name */
-      this.provider = "openrouter";
-      this.lastRequestTime = 0;
-      this.requestCount = 0;
+      this.provider = "openai";
       this.apiKey = apiKey;
       this.model = model;
       this.tools = tools || [];
       this.endpoint = endpoint;
+      this.mcpServers = mcpServers;
       this.responseLength = responseLength;
-      this.appName = appName;
-      this.appUrl = appUrl;
+      this.verbosity = verbosity;
       this.reasoning_effort = reasoning_effort;
-      this.includeReasoning = includeReasoning;
-      this.reasoningMaxTokens = reasoningMaxTokens;
+      this.enableReasoningSummary = enableReasoningSummary;
+      if (!VISION_SUPPORTED_MODELS.includes(visionModel)) {
+        throw new Error(
+          `Model ${visionModel} does not support vision capabilities.`
+        );
+      }
       this.visionModel = visionModel;
     }
     /**
@@ -2571,31 +2344,6 @@ If it's in another language, summarize in that language.
     getVisionModel() {
       return this.visionModel;
     }
-    /**
-     * Apply rate limiting for free tier models
-     */
-    async applyRateLimiting() {
-      if (!isOpenRouterFreeModel(this.model)) {
-        return;
-      }
-      const now = Date.now();
-      const timeSinceLastRequest = now - this.lastRequestTime;
-      if (timeSinceLastRequest > 6e4) {
-        this.requestCount = 0;
-      }
-      if (this.requestCount >= OPENROUTER_FREE_RATE_LIMIT_PER_MINUTE) {
-        const waitTime = 6e4 - timeSinceLastRequest;
-        if (waitTime > 0) {
-          console.log(
-            `Rate limit reached for free tier. Waiting ${waitTime}ms...`
-          );
-          await new Promise((resolve) => setTimeout(resolve, waitTime));
-          this.requestCount = 0;
-        }
-      }
-      this.lastRequestTime = now;
-      this.requestCount++;
-    }
     /**
      * Process chat messages
      * @param messages Array of messages to send
@@ -2603,56 +2351,65 @@ If it's in another language, summarize in that language.
      * @param onCompleteResponse Callback to execute when response is complete
      */
     async processChat(messages, onPartialResponse, onCompleteResponse) {
-      await this.applyRateLimiting();
-      if (this.tools.length === 0) {
-        const res = await this.callOpenRouter(messages, this.model, true);
-        const full = await this.handleStream(res, onPartialResponse);
-        await onCompleteResponse(full);
-        return;
-      }
-      const { blocks, stop_reason } = await this.chatOnce(messages);
-      if (stop_reason === "end") {
-        const full = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-        await onCompleteResponse(full);
-        return;
-      }
-      throw new Error(
-        "processChat received tool_calls. ChatProcessor must use chatOnce() loop when tools are enabled."
-      );
+      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 this.parseResponsesStream(
+                res,
+                onPartialResponse
+              );
+              return StreamTextAccumulator.getFullText(result.blocks);
+            }
+            return this.handleStream(res, onPartialResponse);
+          } catch (error) {
+            console.error("[processChat] Error in streaming/completion:", error);
+            throw error;
+          }
+        },
+        runWithTools: () => this.chatOnce(messages, true, onPartialResponse),
+        onCompleteResponse,
+        toolErrorMessage: "processChat received tool_calls. ChatProcessor must use chatOnce() loop when tools are enabled."
+      });
     }
     /**
      * 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) {
-      if (!isOpenRouterVisionModel(this.visionModel)) {
-        throw new Error(
-          `Model ${this.visionModel} does not support vision capabilities.`
-        );
-      }
-      await this.applyRateLimiting();
       try {
-        if (this.tools.length === 0) {
-          const res = await this.callOpenRouter(messages, this.visionModel, true);
-          const full = await this.handleStream(res, onPartialResponse);
-          await onCompleteResponse(full);
-          return;
-        }
-        const { blocks, stop_reason } = await this.visionChatOnce(
-          messages,
-          true,
-          onPartialResponse
-        );
-        if (stop_reason === "end") {
-          const full = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-          await onCompleteResponse(full);
-          return;
-        }
-        throw new Error(
-          "processVisionChat received tool_calls. ChatProcessor must use visionChatOnce() loop when tools are enabled."
-        );
+        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 this.parseResponsesStream(
+                  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;
@@ -2668,14 +2425,8 @@ If it's in another language, summarize in that language.
      */
     async chatOnce(messages, stream = true, onPartialResponse = () => {
     }, maxTokens) {
-      await this.applyRateLimiting();
-      const res = await this.callOpenRouter(
-        messages,
-        this.model,
-        stream,
-        maxTokens
-      );
-      return stream ? this.parseStream(res, onPartialResponse) : this.parseOneShot(await res.json());
+      const res = await this.callOpenAI(messages, this.model, stream, maxTokens);
+      return this.parseResponse(res, stream, onPartialResponse);
     }
     /**
      * Process vision chat messages with tools
@@ -2687,121 +2438,192 @@ If it's in another language, summarize in that language.
      */
     async visionChatOnce(messages, stream = false, onPartialResponse = () => {
     }, maxTokens) {
-      if (!isOpenRouterVisionModel(this.visionModel)) {
-        throw new Error(
-          `Model ${this.visionModel} does not support vision capabilities.`
-        );
-      }
-      await this.applyRateLimiting();
-      const res = await this.callOpenRouter(
+      const res = await this.callOpenAI(
         messages,
         this.visionModel,
         stream,
         maxTokens
       );
-      return stream ? this.parseStream(res, onPartialResponse) : this.parseOneShot(await res.json());
+      return this.parseResponse(res, stream, onPartialResponse);
     }
     /**
-     * Call OpenRouter API
+     * Parse response based on endpoint type
      */
-    async callOpenRouter(messages, model, stream = false, maxTokens) {
-      const body = this.buildRequestBody(messages, model, stream, maxTokens);
-      const headers = {
-        Authorization: `Bearer ${this.apiKey}`
-      };
-      if (this.appUrl) {
-        headers["HTTP-Referer"] = this.appUrl;
-      }
-      if (this.appName) {
-        headers["X-Title"] = this.appName;
+    async parseResponse(res, stream, onPartialResponse) {
+      const isResponsesAPI = this.endpoint === ENDPOINT_OPENAI_RESPONSES_API;
+      if (isResponsesAPI) {
+        return stream ? this.parseResponsesStream(res, onPartialResponse) : this.parseResponsesOneShot(await res.json());
       }
-      const res = await ChatServiceHttpClient.post(this.endpoint, body, headers);
+      return stream ? this.parseStream(res, onPartialResponse) : this.parseOneShot(await res.json());
+    }
+    async callOpenAI(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 for OpenRouter API (OpenAI-compatible format)
+     * 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 = {
         model,
-        messages,
         stream
       };
       const tokenLimit = maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength);
-      if (tokenLimit) {
-        console.warn(
-          `OpenRouter: Token limits are not supported for gpt-oss-20b model due to known issues. Using unlimited tokens instead.`
-        );
+      if (isResponsesAPI) {
+        body.max_output_tokens = tokenLimit;
+      } else {
+        body.max_completion_tokens = tokenLimit;
       }
-      if (this.reasoning_effort !== void 0 || this.includeReasoning !== void 0 || this.reasoningMaxTokens) {
-        body.reasoning = {};
-        if (this.reasoning_effort && this.reasoning_effort !== "none") {
-          const effort = this.reasoning_effort === "minimal" ? "low" : this.reasoning_effort;
-          body.reasoning.effort = effort;
-        }
-        if (this.reasoning_effort === "none" || this.includeReasoning !== true) {
-          body.reasoning.exclude = true;
-        }
-        if (this.reasoningMaxTokens) {
-          body.reasoning.max_tokens = this.reasoningMaxTokens;
-        }
+      if (isResponsesAPI) {
+        body.input = this.cleanMessagesForResponsesAPI(messages);
       } else {
-        body.reasoning = { exclude: true };
+        body.messages = messages;
       }
-      if (this.tools.length > 0) {
-        body.tools = this.tools.map((t) => ({
-          type: "function",
-          function: {
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters
+      if (isGPT5Model(model)) {
+        if (isResponsesAPI) {
+          if (this.reasoning_effort) {
+            body.reasoning = {
+              ...body.reasoning,
+              effort: this.reasoning_effort
+            };
+            if (this.enableReasoningSummary) {
+              body.reasoning.summary = "auto";
+            }
           }
-        }));
-        body.tool_choice = "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;
     }
     /**
-     * Handle streaming response from OpenRouter
-     * OpenRouter uses SSE format with potential comment lines
+     * Validate MCP servers compatibility with the current endpoint
      */
-    async handleStream(res, onPartial) {
-      const reader = res.body.getReader();
-      const dec = new TextDecoder();
-      let buffer = "";
-      let full = "";
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += dec.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          const trimmedLine = line.trim();
-          if (!trimmedLine || trimmedLine.startsWith(":")) continue;
-          if (!trimmedLine.startsWith("data:")) continue;
-          const jsonStr = trimmedLine.slice(5).trim();
-          if (jsonStr === "[DONE]") {
-            return full;
-          }
-          try {
-            const json = JSON.parse(jsonStr);
-            const content = json.choices?.[0]?.delta?.content || "";
-            if (content) {
-              onPartial(content);
-              full += content;
+    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") {
+          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
+              };
             }
-          } catch (e) {
-            console.debug("Failed to parse SSE data:", jsonStr);
-          }
+            return block;
+          });
+        } else {
+          cleanMsg.content = msg.content;
         }
+        return cleanMsg;
+      });
+    }
+    /**
+     * Build tools definition based on the endpoint type
+     */
+    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 full;
+      return toolDefs;
     }
     /**
-     * Parse streaming response with tool support
+     * 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;
+        }
+        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}`
+          };
+        }
+        return mcpDef;
+      });
+    }
+    async handleStream(res, onPartial) {
+      return parseOpenAICompatibleTextStream(res, onPartial);
+    }
     async parseStream(res, onPartial) {
+      return parseOpenAICompatibleToolStream(res, onPartial, {
+        appendTextBlock: StreamTextAccumulator.addTextBlock
+      });
+    }
+    parseOneShot(data) {
+      return parseOpenAICompatibleOneShot(data);
+    }
+    /**
+     * Parse streaming response from Responses API (SSE format)
+     */
+    async parseResponsesStream(res, onPartial) {
       const reader = res.body.getReader();
       const dec = new TextDecoder();
       const textBlocks = [];
@@ -2811,164 +2633,221 @@ If it's in another language, summarize in that language.
         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 (const line of lines) {
-          const trimmedLine = line.trim();
-          if (!trimmedLine || trimmedLine.startsWith(":")) continue;
-          if (!trimmedLine.startsWith("data:")) continue;
-          const payload = trimmedLine.slice(5).trim();
-          if (payload === "[DONE]") {
-            break;
-          }
-          try {
-            const json = JSON.parse(payload);
-            const delta = json.choices?.[0]?.delta;
-            if (delta?.content) {
-              onPartial(delta.content);
-              StreamTextAccumulator.append(textBlocks, delta.content);
-            }
-            if (delta?.tool_calls) {
-              delta.tool_calls.forEach((c) => {
-                const entry = toolCallsMap.get(c.index) ?? {
-                  id: c.id,
-                  name: c.function?.name,
-                  args: ""
-                };
-                entry.args += c.function?.arguments || "";
-                toolCallsMap.set(c.index, entry);
-              });
+        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);
+              const completionResult = this.handleResponsesSSEEvent(
+                eventType,
+                json,
+                onPartial,
+                textBlocks,
+                toolCallsMap
+              );
+              if (completionResult === "completed") {
+              }
+            } catch (e) {
+              console.warn("Failed to parse SSE data:", eventData);
             }
-          } catch (e) {
-            console.debug("Failed to parse SSE data:", payload);
+            eventType = "";
+            eventData = "";
           }
         }
       }
-      const toolBlocks = Array.from(toolCallsMap.entries()).sort((a, b) => a[0] - b[0]).map(([_, e]) => ({
-        type: "tool_use",
-        id: e.id,
-        name: e.name,
-        input: JSON.parse(e.args || "{}")
-      }));
-      const blocks = [...textBlocks, ...toolBlocks];
-      return {
-        blocks,
-        stop_reason: toolBlocks.length ? "tool_use" : "end"
-      };
+      const toolBlocks = Array.from(toolCallsMap.values()).map(
+        (tool) => ({
+          type: "tool_use",
+          id: tool.id,
+          name: tool.name,
+          input: tool.input || {}
+        })
+      );
+      const blocks = [...textBlocks, ...toolBlocks];
+      return {
+        blocks,
+        stop_reason: toolBlocks.length ? "tool_use" : "end"
+      };
+    }
+    /**
+     * Handle specific SSE events from Responses API
+     * @returns 'completed' if the response is completed, undefined otherwise
+     */
+    handleResponsesSSEEvent(eventType, data, onPartial, textBlocks, toolCallsMap) {
+      switch (eventType) {
+        // Item addition events
+        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;
+        // Initial content part events
+        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;
+        // Text delta events
+        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;
+        // Text completion events - do not add text here as it's already accumulated via delta events
+        case "response.output_text.done":
+        case "response.content_part.done":
+          break;
+        // Response completion events
+        case "response.completed":
+          return "completed";
+        // GPT-5 reasoning token events (not visible but counted for billing)
+        case "response.reasoning.started":
+        case "response.reasoning.delta":
+        case "response.reasoning.done":
+          break;
+        default:
+          break;
+      }
+      return void 0;
     }
     /**
-     * Parse non-streaming response
+     * Parse non-streaming response from Responses API
      */
-    parseOneShot(data) {
-      const choice = data.choices?.[0];
+    parseResponsesOneShot(data) {
       const blocks = [];
-      if (choice?.finish_reason === "tool_calls" && choice?.message?.tool_calls) {
-        choice.message.tool_calls.forEach(
-          (c) => blocks.push({
-            type: "tool_use",
-            id: c.id,
-            name: c.function?.name,
-            input: JSON.parse(c.function?.arguments || "{}")
-          })
-        );
-      } else if (choice?.message?.content) {
-        blocks.push({ type: "text", text: choice.message.content });
+      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: choice?.finish_reason === "tool_calls" ? "tool_use" : "end"
+        stop_reason: blocks.some((b) => b.type === "tool_use") ? "tool_use" : "end"
       };
     }
   };
 
-  // src/services/providers/openrouter/OpenRouterChatServiceProvider.ts
-  var OpenRouterChatServiceProvider = class {
+  // src/services/providers/openai/OpenAIChatServiceProvider.ts
+  var OpenAIChatServiceProvider = class {
     /**
      * Create a chat service instance
      * @param options Service options
-     * @returns OpenRouterChatService instance
+     * @returns OpenAIChatService instance
      */
     createChatService(options) {
-      const visionModel = options.visionModel || options.model || this.getDefaultModel();
-      if (options.visionModel && !this.supportsVisionForModel(options.visionModel)) {
-        throw new Error(
-          `Model ${options.visionModel} does not support vision capabilities.`
-        );
+      const optimizedOptions = this.optimizeGPT5Options(options);
+      const visionModel = resolveVisionModel({
+        model: optimizedOptions.model,
+        visionModel: optimizedOptions.visionModel,
+        defaultModel: this.getDefaultModel(),
+        defaultVisionModel: this.getDefaultModel(),
+        supportsVisionForModel: (model) => this.supportsVisionForModel(model),
+        validate: "resolved"
+      });
+      const tools = optimizedOptions.tools;
+      const mcpServers = optimizedOptions.mcpServers ?? [];
+      const modelName = optimizedOptions.model || this.getDefaultModel();
+      let shouldUseResponsesAPI = false;
+      if (mcpServers.length > 0) {
+        shouldUseResponsesAPI = true;
+      } else if (isGPT5Model(modelName)) {
+        const preference = optimizedOptions.gpt5EndpointPreference || "chat";
+        shouldUseResponsesAPI = preference === "responses";
       }
-      const tools = options.tools;
-      const appName = options.appName;
-      const appUrl = options.appUrl;
-      return new OpenRouterChatService(
-        options.apiKey,
-        options.model || this.getDefaultModel(),
+      const endpoint = optimizedOptions.endpoint || (shouldUseResponsesAPI ? ENDPOINT_OPENAI_RESPONSES_API : ENDPOINT_OPENAI_CHAT_COMPLETIONS_API);
+      return new OpenAIChatService(
+        optimizedOptions.apiKey,
+        modelName,
         visionModel,
         tools,
-        options.endpoint,
-        options.responseLength,
-        appName,
-        appUrl,
-        options.reasoning_effort,
-        options.includeReasoning,
-        options.reasoningMaxTokens
+        endpoint,
+        mcpServers,
+        optimizedOptions.responseLength,
+        optimizedOptions.verbosity,
+        optimizedOptions.reasoning_effort,
+        optimizedOptions.enableReasoningSummary
       );
     }
     /**
      * Get the provider name
-     * @returns Provider name ('openrouter')
+     * @returns Provider name ('openai')
      */
     getProviderName() {
-      return "openrouter";
+      return "openai";
     }
     /**
      * Get the list of supported models
-     * Supports a curated list of OpenRouter models
      * @returns Array of supported model names
      */
     getSupportedModels() {
       return [
-        // Free models
-        MODEL_GPT_OSS_20B_FREE,
-        MODEL_ZAI_GLM_4_5_AIR_FREE,
-        // OpenAI models
-        MODEL_OPENAI_GPT_5_1_CHAT,
-        MODEL_OPENAI_GPT_5_1_CODEX,
-        MODEL_OPENAI_GPT_5_MINI,
-        MODEL_OPENAI_GPT_5_NANO,
-        MODEL_OPENAI_GPT_4O,
-        MODEL_OPENAI_GPT_4_1_MINI,
-        MODEL_OPENAI_GPT_4_1_NANO,
-        // Anthropic models
-        MODEL_ANTHROPIC_CLAUDE_OPUS_4,
-        MODEL_ANTHROPIC_CLAUDE_SONNET_4,
-        MODEL_ANTHROPIC_CLAUDE_3_7_SONNET,
-        MODEL_ANTHROPIC_CLAUDE_3_5_SONNET,
-        MODEL_ANTHROPIC_CLAUDE_4_5_HAIKU,
-        // Gemini models
-        MODEL_GOOGLE_GEMINI_2_5_PRO,
-        MODEL_GOOGLE_GEMINI_2_5_FLASH,
-        MODEL_GOOGLE_GEMINI_2_5_FLASH_LITE_PREVIEW_09_2025,
-        // Z.ai models
-        MODEL_ZAI_GLM_4_7_FLASH,
-        MODEL_ZAI_GLM_4_5_AIR,
-        // Other models
-        MODEL_MOONSHOTAI_KIMI_K2_5
+        MODEL_GPT_5_NANO,
+        MODEL_GPT_5_MINI,
+        MODEL_GPT_5,
+        MODEL_GPT_5_1,
+        MODEL_GPT_4_1,
+        MODEL_GPT_4_1_MINI,
+        MODEL_GPT_4_1_NANO,
+        MODEL_GPT_4O_MINI,
+        MODEL_GPT_4O,
+        MODEL_O3_MINI,
+        MODEL_O1_MINI,
+        MODEL_O1,
+        MODEL_GPT_4_5_PREVIEW
       ];
     }
     /**
      * Get the default model
-     * @returns Default model name (gpt-oss-20b:free)
+     * @returns Default model name
      */
     getDefaultModel() {
-      return MODEL_GPT_OSS_20B_FREE;
+      return MODEL_GPT_5_NANO;
     }
     /**
      * Check if this provider supports vision (image processing)
-     * @returns Vision support status (false - gpt-oss-20b does not support vision)
+     * @returns Vision support status (true)
      */
     supportsVision() {
-      return this.getSupportedModels().some(
-        (model) => this.supportsVisionForModel(model)
-      );
+      return true;
     }
     /**
      * Check if a specific model supports vision capabilities
@@ -2976,388 +2855,437 @@ If it's in another language, summarize in that language.
      * @returns True if the model supports vision, false otherwise
      */
     supportsVisionForModel(model) {
-      return isOpenRouterVisionModel(model);
+      return VISION_SUPPORTED_MODELS.includes(model);
     }
     /**
-     * Get list of free tier models
-     * @returns Array of free model names
+     * Apply GPT-5 specific optimizations to options
+     * @param options Original chat service options
+     * @returns Optimized options for GPT-5 usage
      */
-    getFreeModels() {
-      return OPENROUTER_FREE_MODELS;
+    optimizeGPT5Options(options) {
+      const modelName = options.model || this.getDefaultModel();
+      if (!isGPT5Model(modelName)) {
+        return options;
+      }
+      const optimized = { ...options };
+      if (options.gpt5Preset) {
+        const preset = GPT5_PRESETS[options.gpt5Preset];
+        optimized.reasoning_effort = preset.reasoning_effort;
+        optimized.verbosity = preset.verbosity;
+      } else {
+        if (!options.reasoning_effort) {
+          optimized.reasoning_effort = this.getDefaultReasoningEffortForModel(modelName);
+        }
+      }
+      optimized.reasoning_effort = this.normalizeReasoningEffort(
+        modelName,
+        optimized.reasoning_effort
+      );
+      return optimized;
     }
     /**
-     * Check if a model is free tier
-     * @param model Model name to check
-     * @returns True if the model is free
+     * Determine the default reasoning effort for GPT-5 family models
+     * GPT-5.1 defaults to 'none' (fastest), earlier GPT-5 defaults to 'medium'
      */
-    isModelFree(model) {
-      return OPENROUTER_FREE_MODELS.includes(model) || model.endsWith(":free");
+    getDefaultReasoningEffortForModel(modelName) {
+      if (modelName === MODEL_GPT_5_1) {
+        return "none";
+      }
+      return "medium";
+    }
+    normalizeReasoningEffort(modelName, effort) {
+      if (!effort) {
+        return void 0;
+      }
+      if (effort === "none" && !allowsReasoningNone(modelName)) {
+        return this.getDefaultReasoningEffortForModel(modelName);
+      }
+      if (effort === "minimal" && !allowsReasoningMinimal(modelName)) {
+        return "none";
+      }
+      return effort;
     }
   };
 
-  // src/services/providers/zai/ZAIChatService.ts
-  var ZAIChatService = class {
+  // src/services/providers/openrouter/OpenRouterChatService.ts
+  var OpenRouterChatService = class {
     /**
      * Constructor
-     * @param apiKey Z.ai API key
+     * @param apiKey OpenRouter API key
      * @param model Name of the model to use
      * @param visionModel Name of the vision model
+     * @param tools Tool definitions (optional)
+     * @param endpoint API endpoint (optional)
+     * @param responseLength Response length configuration (optional)
+     * @param appName Application name for OpenRouter analytics (optional)
+     * @param appUrl Application URL for OpenRouter analytics (optional)
+     * @param reasoning_effort Reasoning effort level (optional)
+     * @param includeReasoning Whether to include reasoning in response (optional)
+     * @param reasoningMaxTokens Maximum tokens for reasoning (optional)
      */
-    constructor(apiKey, model = MODEL_GLM_4_7, visionModel = MODEL_GLM_4_6V_FLASH, tools, endpoint = ENDPOINT_ZAI_CHAT_COMPLETIONS_API, responseLength, responseFormat, thinking) {
+    constructor(apiKey, model = MODEL_GPT_OSS_20B_FREE, visionModel = MODEL_GPT_OSS_20B_FREE, tools, endpoint = ENDPOINT_OPENROUTER_API, responseLength, appName, appUrl, reasoning_effort, includeReasoning, reasoningMaxTokens) {
       /** Provider name */
-      this.provider = "zai";
+      this.provider = "openrouter";
+      this.lastRequestTime = 0;
+      this.requestCount = 0;
       this.apiKey = apiKey;
       this.model = model;
       this.tools = tools || [];
       this.endpoint = endpoint;
       this.responseLength = responseLength;
-      this.responseFormat = responseFormat;
-      this.thinking = thinking ?? { type: "disabled" };
+      this.appName = appName;
+      this.appUrl = appUrl;
+      this.reasoning_effort = reasoning_effort;
+      this.includeReasoning = includeReasoning;
+      this.reasoningMaxTokens = reasoningMaxTokens;
       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
+     * Apply rate limiting for free tier models
      */
-    async processChat(messages, onPartialResponse, onCompleteResponse) {
-      if (this.tools.length === 0) {
-        const res = await this.callZAI(messages, this.model, true);
-        const full = await this.handleStream(res, onPartialResponse);
-        await onCompleteResponse(full);
+    async applyRateLimiting() {
+      if (!isOpenRouterFreeModel(this.model)) {
         return;
       }
-      const { blocks, stop_reason } = await this.chatOnce(messages);
-      if (stop_reason === "end") {
-        const full = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-        await onCompleteResponse(full);
-        return;
+      const now = Date.now();
+      const timeSinceLastRequest = now - this.lastRequestTime;
+      if (timeSinceLastRequest > 6e4) {
+        this.requestCount = 0;
       }
-      throw new Error(
-        "processChat received tool_calls. ChatProcessor must use chatOnce() loop when tools are enabled."
-      );
+      if (this.requestCount >= OPENROUTER_FREE_RATE_LIMIT_PER_MINUTE) {
+        const waitTime = 6e4 - timeSinceLastRequest;
+        if (waitTime > 0) {
+          console.log(
+            `Rate limit reached for free tier. Waiting ${waitTime}ms...`
+          );
+          await new Promise((resolve) => setTimeout(resolve, waitTime));
+          this.requestCount = 0;
+        }
+      }
+      this.lastRequestTime = now;
+      this.requestCount++;
+    }
+    /**
+     * 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 this.applyRateLimiting();
+      await processChatWithOptionalTools({
+        hasTools: this.tools.length > 0,
+        runWithoutTools: async () => {
+          const res = await this.callOpenRouter(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."
+      });
     }
     /**
      * 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
      */
     async processVisionChat(messages, onPartialResponse, onCompleteResponse) {
-      if (!isZaiVisionModel(this.visionModel)) {
+      if (!isOpenRouterVisionModel(this.visionModel)) {
         throw new Error(
           `Model ${this.visionModel} does not support vision capabilities.`
         );
       }
-      if (this.tools.length === 0) {
-        const res = await this.callZAI(messages, this.visionModel, true);
-        const full = await this.handleStream(res, onPartialResponse);
-        await onCompleteResponse(full);
-        return;
-      }
-      const { blocks, stop_reason } = await this.visionChatOnce(
-        messages,
-        true,
-        onPartialResponse
-      );
-      if (stop_reason === "end") {
-        const full = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-        await onCompleteResponse(full);
-        return;
+      await this.applyRateLimiting();
+      try {
+        await processChatWithOptionalTools({
+          hasTools: this.tools.length > 0,
+          runWithoutTools: async () => {
+            const res = await this.callOpenRouter(
+              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."
+        });
+      } catch (error) {
+        console.error("Error in processVisionChat:", error);
+        throw error;
       }
-      throw new Error(
-        "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.callZAI(messages, this.model, stream, maxTokens);
-      return this.parseResponse(res, stream, onPartialResponse);
+      await this.applyRateLimiting();
+      const res = await this.callOpenRouter(
+        messages,
+        this.model,
+        stream,
+        maxTokens
+      );
+      return stream ? this.parseStream(res, onPartialResponse) : this.parseOneShot(await res.json());
     }
     /**
      * 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) {
-      if (!isZaiVisionModel(this.visionModel)) {
+      if (!isOpenRouterVisionModel(this.visionModel)) {
         throw new Error(
           `Model ${this.visionModel} does not support vision capabilities.`
         );
       }
-      const res = await this.callZAI(
+      await this.applyRateLimiting();
+      const res = await this.callOpenRouter(
         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 callZAI(messages, model, stream = false, maxTokens) {
+    /**
+     * Call OpenRouter API
+     */
+    async callOpenRouter(messages, model, stream = false, maxTokens) {
       const body = this.buildRequestBody(messages, model, stream, maxTokens);
-      const res = await ChatServiceHttpClient.post(this.endpoint, body, {
+      const headers = {
         Authorization: `Bearer ${this.apiKey}`
-      });
+      };
+      if (this.appUrl) {
+        headers["HTTP-Referer"] = this.appUrl;
+      }
+      if (this.appName) {
+        headers["X-Title"] = this.appName;
+      }
+      const res = await ChatServiceHttpClient.post(this.endpoint, body, headers);
       return res;
     }
     /**
-     * Build request body (OpenAI-compatible Chat Completions)
+     * Build request body for OpenRouter API (OpenAI-compatible format)
      */
     buildRequestBody(messages, model, stream, maxTokens) {
       const body = {
         model,
-        stream,
-        messages
+        messages,
+        stream
       };
       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;
+      if (tokenLimit) {
+        console.warn(
+          `OpenRouter: Token limits are not supported for gpt-oss-20b model due to known issues. Using unlimited tokens instead.`
+        );
       }
-      if (this.thinking) {
-        body.thinking = this.thinking;
+      if (this.reasoning_effort !== void 0 || this.includeReasoning !== void 0 || this.reasoningMaxTokens) {
+        body.reasoning = {};
+        if (this.reasoning_effort && this.reasoning_effort !== "none") {
+          const effort = this.reasoning_effort === "minimal" ? "low" : this.reasoning_effort;
+          body.reasoning.effort = effort;
+        }
+        if (this.reasoning_effort === "none" || this.includeReasoning !== true) {
+          body.reasoning.exclude = true;
+        }
+        if (this.reasoningMaxTokens) {
+          body.reasoning.max_tokens = this.reasoningMaxTokens;
+        }
+      } else {
+        body.reasoning = { exclude: true };
       }
-      const tools = this.buildToolsDefinition();
-      if (tools.length > 0) {
-        body.tools = tools;
+      if (this.tools.length > 0) {
+        body.tools = buildOpenAICompatibleTools(this.tools, "chat-completions");
         body.tool_choice = "auto";
-        if (stream && isZaiToolStreamModel(model)) {
-          body.tool_stream = true;
-        }
       }
       return body;
     }
-    buildToolsDefinition() {
-      if (this.tools.length === 0) return [];
-      return this.tools.map((t) => ({
-        type: "function",
-        function: {
-          name: t.name,
-          description: t.description,
-          parameters: t.parameters
-        }
-      }));
-    }
+    /**
+     * Handle streaming response from OpenRouter
+     * OpenRouter uses SSE format with potential comment lines
+     */
     async handleStream(res, onPartial) {
-      const reader = res.body.getReader();
-      const dec = new TextDecoder();
-      let full = "";
-      let buf = "";
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buf += dec.decode(value, { stream: true });
-        const lines = buf.split("\n");
-        buf = lines.pop() || "";
-        for (const line of lines) {
-          const trimmedLine = line.trim();
-          if (!trimmedLine || trimmedLine.startsWith(":")) continue;
-          if (!trimmedLine.startsWith("data:")) continue;
-          const payload = trimmedLine.slice(5).trim();
-          if (payload === "[DONE]") {
-            break;
-          }
-          try {
-            const json = JSON.parse(payload);
-            const content = json.choices?.[0]?.delta?.content || "";
-            if (content) {
-              onPartial(content);
-              full += content;
-            }
-          } catch (e) {
-            console.debug("Failed to parse SSE data:", payload);
-          }
-        }
-      }
-      return full;
+      return parseOpenAICompatibleTextStream(res, onPartial, {
+        onJsonError: (payload) => console.debug("Failed to parse SSE data:", payload)
+      });
     }
     /**
      * Parse streaming response with tool support
      */
     async parseStream(res, onPartial) {
-      const reader = res.body.getReader();
-      const dec = new TextDecoder();
-      const textBlocks = [];
-      const toolCallsMap = /* @__PURE__ */ new Map();
-      let buf = "";
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buf += dec.decode(value, { stream: true });
-        const lines = buf.split("\n");
-        buf = lines.pop() || "";
-        for (const line of lines) {
-          const trimmedLine = line.trim();
-          if (!trimmedLine || trimmedLine.startsWith(":")) continue;
-          if (!trimmedLine.startsWith("data:")) continue;
-          const payload = trimmedLine.slice(5).trim();
-          if (payload === "[DONE]") {
-            break;
-          }
-          try {
-            const json = JSON.parse(payload);
-            const delta = json.choices?.[0]?.delta;
-            if (delta?.content) {
-              onPartial(delta.content);
-              StreamTextAccumulator.append(textBlocks, delta.content);
-            }
-            if (delta?.tool_calls) {
-              delta.tool_calls.forEach((c) => {
-                const entry = toolCallsMap.get(c.index) ?? {
-                  id: c.id,
-                  name: c.function?.name,
-                  args: ""
-                };
-                entry.args += c.function?.arguments || "";
-                toolCallsMap.set(c.index, entry);
-              });
-            }
-          } catch (e) {
-            console.debug("Failed to parse SSE data:", payload);
-          }
-        }
-      }
-      const toolBlocks = Array.from(toolCallsMap.entries()).sort((a, b) => a[0] - b[0]).map(([_, e]) => ({
-        type: "tool_use",
-        id: e.id,
-        name: e.name,
-        input: JSON.parse(e.args || "{}")
-      }));
-      const blocks = [...textBlocks, ...toolBlocks];
-      return {
-        blocks,
-        stop_reason: toolBlocks.length ? "tool_use" : "end"
-      };
+      return parseOpenAICompatibleToolStream(res, onPartial, {
+        onJsonError: (payload) => console.debug("Failed to parse SSE data:", payload)
+      });
     }
     /**
      * Parse non-streaming response
      */
     parseOneShot(data) {
-      const choice = data.choices?.[0];
-      const blocks = [];
-      if (choice?.message?.tool_calls?.length) {
-        choice.message.tool_calls.forEach(
-          (c) => blocks.push({
-            type: "tool_use",
-            id: c.id,
-            name: c.function?.name,
-            input: JSON.parse(c.function?.arguments || "{}")
-          })
-        );
-      } else if (choice?.message?.content) {
-        blocks.push({ type: "text", text: choice.message.content });
-      }
-      return {
-        blocks,
-        stop_reason: blocks.some((b) => b.type === "tool_use") ? "tool_use" : "end"
-      };
+      return parseOpenAICompatibleOneShot(data);
     }
   };
 
-  // src/services/providers/zai/ZAIChatServiceProvider.ts
-  var ZAIChatServiceProvider = class {
+  // src/services/providers/openrouter/OpenRouterChatServiceProvider.ts
+  var OpenRouterChatServiceProvider = class {
     /**
      * Create a chat service instance
+     * @param options Service options
+     * @returns OpenRouterChatService instance
      */
     createChatService(options) {
-      const model = options.model || this.getDefaultModel();
-      const visionModel = options.visionModel || (this.supportsVisionForModel(model) ? model : this.getDefaultVisionModel());
-      if (options.visionModel && !this.supportsVisionForModel(options.visionModel)) {
-        throw new Error(
-          `Model ${options.visionModel} does not support vision capabilities.`
-        );
-      }
+      const visionModel = resolveVisionModel({
+        model: options.model,
+        visionModel: options.visionModel,
+        defaultModel: this.getDefaultModel(),
+        defaultVisionModel: options.model || this.getDefaultModel(),
+        supportsVisionForModel: (visionModel2) => this.supportsVisionForModel(visionModel2),
+        validate: "explicit"
+      });
       const tools = options.tools;
-      const thinking = options.thinking ?? { type: "disabled" };
-      return new ZAIChatService(
+      const appName = options.appName;
+      const appUrl = options.appUrl;
+      return new OpenRouterChatService(
         options.apiKey,
-        model,
+        options.model || this.getDefaultModel(),
         visionModel,
         tools,
-        options.endpoint || ENDPOINT_ZAI_CHAT_COMPLETIONS_API,
+        options.endpoint,
         options.responseLength,
-        options.responseFormat,
-        thinking
+        appName,
+        appUrl,
+        options.reasoning_effort,
+        options.includeReasoning,
+        options.reasoningMaxTokens
       );
     }
     /**
      * Get the provider name
+     * @returns Provider name ('openrouter')
      */
     getProviderName() {
-      return "zai";
+      return "openrouter";
     }
     /**
      * Get the list of supported models
+     * Supports a curated list of OpenRouter models
+     * @returns Array of supported model names
      */
     getSupportedModels() {
       return [
-        MODEL_GLM_4_7,
-        MODEL_GLM_4_7_FLASHX,
-        MODEL_GLM_4_7_FLASH,
-        MODEL_GLM_4_6,
-        MODEL_GLM_4_6V,
-        MODEL_GLM_4_6V_FLASHX,
-        MODEL_GLM_4_6V_FLASH
+        // Free models
+        MODEL_GPT_OSS_20B_FREE,
+        MODEL_ZAI_GLM_4_5_AIR_FREE,
+        // OpenAI models
+        MODEL_OPENAI_GPT_5_1_CHAT,
+        MODEL_OPENAI_GPT_5_1_CODEX,
+        MODEL_OPENAI_GPT_5_MINI,
+        MODEL_OPENAI_GPT_5_NANO,
+        MODEL_OPENAI_GPT_4O,
+        MODEL_OPENAI_GPT_4_1_MINI,
+        MODEL_OPENAI_GPT_4_1_NANO,
+        // Anthropic models
+        MODEL_ANTHROPIC_CLAUDE_OPUS_4,
+        MODEL_ANTHROPIC_CLAUDE_SONNET_4,
+        MODEL_ANTHROPIC_CLAUDE_3_7_SONNET,
+        MODEL_ANTHROPIC_CLAUDE_3_5_SONNET,
+        MODEL_ANTHROPIC_CLAUDE_4_5_HAIKU,
+        // Gemini models
+        MODEL_GOOGLE_GEMINI_2_5_PRO,
+        MODEL_GOOGLE_GEMINI_2_5_FLASH,
+        MODEL_GOOGLE_GEMINI_2_5_FLASH_LITE_PREVIEW_09_2025,
+        // Z.ai models
+        MODEL_ZAI_GLM_4_7_FLASH,
+        MODEL_ZAI_GLM_4_5_AIR,
+        // Other models
+        MODEL_MOONSHOTAI_KIMI_K2_5
       ];
     }
     /**
      * Get the default model
+     * @returns Default model name (gpt-oss-20b:free)
      */
     getDefaultModel() {
-      return MODEL_GLM_4_7;
+      return MODEL_GPT_OSS_20B_FREE;
     }
     /**
-     * Get the default vision model
+     * Check if this provider supports vision (image processing)
+     * @returns Vision support status (false - gpt-oss-20b does not support vision)
      */
-    getDefaultVisionModel() {
-      return MODEL_GLM_4_6V_FLASH;
+    supportsVision() {
+      return this.getSupportedModels().some(
+        (model) => this.supportsVisionForModel(model)
+      );
     }
     /**
-     * Check if this provider supports vision
+     * Check if a specific model supports vision capabilities
+     * @param model The model name to check
+     * @returns True if the model supports vision, false otherwise
      */
-    supportsVision() {
-      return true;
+    supportsVisionForModel(model) {
+      return isOpenRouterVisionModel(model);
     }
     /**
-     * Check if a specific model supports vision capabilities
+     * Get list of free tier models
+     * @returns Array of free model names
+     */
+    getFreeModels() {
+      return OPENROUTER_FREE_MODELS;
+    }
+    /**
+     * Check if a model is free tier
+     * @param model Model name to check
+     * @returns True if the model is free
      */
-    supportsVisionForModel(model) {
-      return isZaiVisionModel(model);
+    isModelFree(model) {
+      return OPENROUTER_FREE_MODELS.includes(model) || model.endsWith(":free");
     }
   };
 
-  // src/services/providers/kimi/KimiChatService.ts
-  var KimiChatService = class {
+  // src/services/providers/zai/ZAIChatService.ts
+  var ZAIChatService = class {
     /**
      * Constructor
-     * @param apiKey Kimi API key
+     * @param apiKey Z.ai API key
      * @param model Name of the model to use
      * @param visionModel Name of the vision model
      */
-    constructor(apiKey, model = MODEL_KIMI_K2_5, visionModel = MODEL_KIMI_K2_5, tools, endpoint = ENDPOINT_KIMI_CHAT_COMPLETIONS_API, responseLength, responseFormat, thinking) {
+    constructor(apiKey, model = MODEL_GLM_4_7, visionModel = MODEL_GLM_4_6V_FLASH, tools, endpoint = ENDPOINT_ZAI_CHAT_COMPLETIONS_API, responseLength, responseFormat, thinking) {
       /** Provider name */
-      this.provider = "kimi";
+      this.provider = "zai";
       this.apiKey = apiKey;
       this.model = model;
       this.tools = tools || [];
       this.endpoint = endpoint;
       this.responseLength = responseLength;
       this.responseFormat = responseFormat;
-      this.thinking = thinking ?? { type: "enabled" };
+      this.thinking = thinking ?? { type: "disabled" };
       this.visionModel = visionModel;
     }
     /**
@@ -3376,57 +3304,43 @@ If it's in another language, summarize in that language.
      * Process chat messages
      */
     async processChat(messages, onPartialResponse, onCompleteResponse) {
-      if (this.tools.length === 0) {
-        const res = await this.callKimi(messages, this.model, true);
-        const full = await this.handleStream(res, onPartialResponse);
-        await onCompleteResponse(full);
-        return;
-      }
-      const { blocks, stop_reason } = await this.chatOnce(messages);
-      if (stop_reason === "end") {
-        const full = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-        await onCompleteResponse(full);
-        return;
-      }
-      throw new Error(
-        "processChat received tool_calls. ChatProcessor must use chatOnce() loop when tools are enabled."
-      );
+      await processChatWithOptionalTools({
+        hasTools: this.tools.length > 0,
+        runWithoutTools: async () => {
+          const res = await this.callZAI(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."
+      });
     }
     /**
      * Process chat messages with images
      */
     async processVisionChat(messages, onPartialResponse, onCompleteResponse) {
-      if (!isKimiVisionModel(this.visionModel)) {
+      if (!isZaiVisionModel(this.visionModel)) {
         throw new Error(
           `Model ${this.visionModel} does not support vision capabilities.`
         );
       }
-      if (this.tools.length === 0) {
-        const res = await this.callKimi(messages, this.visionModel, true);
-        const full = await this.handleStream(res, onPartialResponse);
-        await onCompleteResponse(full);
-        return;
-      }
-      const { blocks, stop_reason } = await this.visionChatOnce(
-        messages,
-        true,
-        onPartialResponse
-      );
-      if (stop_reason === "end") {
-        const full = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
-        await onCompleteResponse(full);
-        return;
-      }
-      throw new Error(
-        "processVisionChat received tool_calls. ChatProcessor must use visionChatOnce() loop when tools are enabled."
-      );
+      await processChatWithOptionalTools({
+        hasTools: this.tools.length > 0,
+        runWithoutTools: async () => {
+          const res = await this.callZAI(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)
      */
     async chatOnce(messages, stream = true, onPartialResponse = () => {
     }, maxTokens) {
-      const res = await this.callKimi(messages, this.model, stream, maxTokens);
+      const res = await this.callZAI(messages, this.model, stream, maxTokens);
       return this.parseResponse(res, stream, onPartialResponse);
     }
     /**
@@ -3434,12 +3348,12 @@ If it's in another language, summarize in that language.
      */
     async visionChatOnce(messages, stream = false, onPartialResponse = () => {
     }, maxTokens) {
-      if (!isKimiVisionModel(this.visionModel)) {
+      if (!isZaiVisionModel(this.visionModel)) {
         throw new Error(
           `Model ${this.visionModel} does not support vision capabilities.`
         );
       }
-      const res = await this.callKimi(
+      const res = await this.callZAI(
         messages,
         this.visionModel,
         stream,
@@ -3450,7 +3364,7 @@ If it's in another language, summarize in that language.
     async parseResponse(res, stream, onPartialResponse) {
       return stream ? this.parseStream(res, onPartialResponse) : this.parseOneShot(await res.json());
     }
-    async callKimi(messages, model, stream = false, maxTokens) {
+    async callZAI(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}`
@@ -3473,179 +3387,66 @@ If it's in another language, summarize in that language.
       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;
-        }
+      if (this.thinking) {
+        body.thinking = this.thinking;
       }
       const tools = this.buildToolsDefinition();
       if (tools.length > 0) {
         body.tools = tools;
         body.tool_choice = "auto";
+        if (stream && isZaiToolStreamModel(model)) {
+          body.tool_stream = true;
+        }
       }
       return body;
     }
-    isSelfHostedEndpoint() {
-      return this.normalizeEndpoint(this.endpoint) !== this.normalizeEndpoint(ENDPOINT_KIMI_CHAT_COMPLETIONS_API);
-    }
-    normalizeEndpoint(value) {
-      return value.replace(/\/+$/, "");
-    }
     buildToolsDefinition() {
-      if (this.tools.length === 0) return [];
-      return this.tools.map((t) => ({
-        type: "function",
-        function: {
-          name: t.name,
-          description: t.description,
-          parameters: t.parameters
-        }
-      }));
+      return buildOpenAICompatibleTools(this.tools, "chat-completions");
     }
     async handleStream(res, onPartial) {
-      const reader = res.body.getReader();
-      const dec = new TextDecoder();
-      let full = "";
-      let buf = "";
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buf += dec.decode(value, { stream: true });
-        const lines = buf.split("\n");
-        buf = lines.pop() || "";
-        for (const line of lines) {
-          const trimmedLine = line.trim();
-          if (!trimmedLine || trimmedLine.startsWith(":")) continue;
-          if (!trimmedLine.startsWith("data:")) continue;
-          const payload = trimmedLine.slice(5).trim();
-          if (payload === "[DONE]") {
-            break;
-          }
-          try {
-            const json = JSON.parse(payload);
-            const content = json.choices?.[0]?.delta?.content || "";
-            if (content) {
-              onPartial(content);
-              full += content;
-            }
-          } catch (e) {
-            console.debug("Failed to parse SSE data:", payload);
-          }
-        }
-      }
-      return full;
+      return parseOpenAICompatibleTextStream(res, onPartial, {
+        onJsonError: (payload) => console.debug("Failed to parse SSE data:", payload)
+      });
     }
     /**
      * Parse streaming response with tool support
      */
     async parseStream(res, onPartial) {
-      const reader = res.body.getReader();
-      const dec = new TextDecoder();
-      const textBlocks = [];
-      const toolCallsMap = /* @__PURE__ */ new Map();
-      let buf = "";
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buf += dec.decode(value, { stream: true });
-        const lines = buf.split("\n");
-        buf = lines.pop() || "";
-        for (const line of lines) {
-          const trimmedLine = line.trim();
-          if (!trimmedLine || trimmedLine.startsWith(":")) continue;
-          if (!trimmedLine.startsWith("data:")) continue;
-          const payload = trimmedLine.slice(5).trim();
-          if (payload === "[DONE]") {
-            break;
-          }
-          try {
-            const json = JSON.parse(payload);
-            const delta = json.choices?.[0]?.delta;
-            if (delta?.content) {
-              onPartial(delta.content);
-              StreamTextAccumulator.append(textBlocks, delta.content);
-            }
-            if (delta?.tool_calls) {
-              delta.tool_calls.forEach((c) => {
-                const entry = toolCallsMap.get(c.index) ?? {
-                  id: c.id,
-                  name: c.function?.name,
-                  args: ""
-                };
-                entry.args += c.function?.arguments || "";
-                toolCallsMap.set(c.index, entry);
-              });
-            }
-          } catch (e) {
-            console.debug("Failed to parse SSE data:", payload);
-          }
-        }
-      }
-      const toolBlocks = Array.from(toolCallsMap.entries()).sort((a, b) => a[0] - b[0]).map(([_, e]) => ({
-        type: "tool_use",
-        id: e.id,
-        name: e.name,
-        input: JSON.parse(e.args || "{}")
-      }));
-      const blocks = [...textBlocks, ...toolBlocks];
-      return {
-        blocks,
-        stop_reason: toolBlocks.length ? "tool_use" : "end"
-      };
+      return parseOpenAICompatibleToolStream(res, onPartial, {
+        onJsonError: (payload) => console.debug("Failed to parse SSE data:", payload)
+      });
     }
     /**
      * Parse non-streaming response
      */
     parseOneShot(data) {
-      const choice = data.choices?.[0];
-      const blocks = [];
-      if (choice?.message?.tool_calls?.length) {
-        choice.message.tool_calls.forEach(
-          (c) => blocks.push({
-            type: "tool_use",
-            id: c.id,
-            name: c.function?.name,
-            input: JSON.parse(c.function?.arguments || "{}")
-          })
-        );
-      } else if (choice?.message?.content) {
-        blocks.push({ type: "text", text: choice.message.content });
-      }
-      return {
-        blocks,
-        stop_reason: blocks.some((b) => b.type === "tool_use") ? "tool_use" : "end"
-      };
+      return parseOpenAICompatibleOneShot(data);
     }
   };
 
-  // src/services/providers/kimi/KimiChatServiceProvider.ts
-  var KimiChatServiceProvider = class {
+  // src/services/providers/zai/ZAIChatServiceProvider.ts
+  var ZAIChatServiceProvider = class {
     /**
      * Create a chat service instance
      */
     createChatService(options) {
-      const endpoint = this.resolveEndpoint(options);
       const model = options.model || this.getDefaultModel();
-      const visionModel = options.visionModel || (this.supportsVisionForModel(model) ? model : this.getDefaultVisionModel());
-      if (options.visionModel && !this.supportsVisionForModel(options.visionModel)) {
-        throw new Error(
-          `Model ${options.visionModel} does not support vision capabilities.`
-        );
-      }
+      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(
+      const thinking = options.thinking ?? { type: "disabled" };
+      return new ZAIChatService(
         options.apiKey,
         model,
         visionModel,
         tools,
-        endpoint,
+        options.endpoint || ENDPOINT_ZAI_CHAT_COMPLETIONS_API,
         options.responseLength,
         options.responseFormat,
         thinking
@@ -3655,25 +3456,33 @@ If it's in another language, summarize in that language.
      * Get the provider name
      */
     getProviderName() {
-      return "kimi";
+      return "zai";
     }
     /**
      * Get the list of supported models
      */
     getSupportedModels() {
-      return [MODEL_KIMI_K2_5];
+      return [
+        MODEL_GLM_4_7,
+        MODEL_GLM_4_7_FLASHX,
+        MODEL_GLM_4_7_FLASH,
+        MODEL_GLM_4_6,
+        MODEL_GLM_4_6V,
+        MODEL_GLM_4_6V_FLASHX,
+        MODEL_GLM_4_6V_FLASH
+      ];
     }
     /**
      * Get the default model
      */
     getDefaultModel() {
-      return MODEL_KIMI_K2_5;
+      return MODEL_GLM_4_7;
     }
     /**
      * Get the default vision model
      */
     getDefaultVisionModel() {
-      return MODEL_KIMI_K2_5;
+      return MODEL_GLM_4_6V_FLASH;
     }
     /**
      * Check if this provider supports vision
@@ -3685,26 +3494,20 @@ If it's in another language, summarize in that language.
      * Check if a specific model supports vision capabilities
      */
     supportsVisionForModel(model) {
-      return isKimiVisionModel(model);
-    }
-    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 `${baseUrl}/chat/completions`;
-      }
-      return ENDPOINT_KIMI_CHAT_COMPLETIONS_API;
-    }
-    normalizeEndpoint(value) {
-      return value.replace(/\/+$/, "");
+      return isZaiVisionModel(model);
     }
   };
 
+  // src/services/providers/index.ts
+  var DEFAULT_CHAT_SERVICE_PROVIDERS = [
+    new OpenAIChatServiceProvider(),
+    new GeminiChatServiceProvider(),
+    new ClaudeChatServiceProvider(),
+    new OpenRouterChatServiceProvider(),
+    new ZAIChatServiceProvider(),
+    new KimiChatServiceProvider()
+  ];
+
   // src/services/ChatServiceFactory.ts
   var ChatServiceFactory = class {
     /**
@@ -3714,12 +3517,6 @@ If it's in another language, summarize in that language.
     static registerProvider(provider) {
       this.providers.set(provider.getProviderName(), provider);
     }
-    /**
-     * Create a chat service with the specified provider name and options
-     * @param providerName Provider name
-     * @param options Service options
-     * @returns Created ChatService instance
-     */
     static createChatService(providerName, options) {
       const provider = this.providers.get(providerName);
       if (!provider) {
@@ -3753,89 +3550,9 @@ If it's in another language, summarize in that language.
   };
   /** Map of registered providers */
   ChatServiceFactory.providers = /* @__PURE__ */ new Map();
-  ChatServiceFactory.registerProvider(new OpenAIChatServiceProvider());
-  ChatServiceFactory.registerProvider(new GeminiChatServiceProvider());
-  ChatServiceFactory.registerProvider(new ClaudeChatServiceProvider());
-  ChatServiceFactory.registerProvider(new OpenRouterChatServiceProvider());
-  ChatServiceFactory.registerProvider(new ZAIChatServiceProvider());
-  ChatServiceFactory.registerProvider(new KimiChatServiceProvider());
-
-  // src/utils/emotionParser.ts
-  var emotions = ["happy", "sad", "angry", "surprised", "neutral"];
-  var EMOTION_TAG_REGEX = /\[([a-z]+)\]/i;
-  var EMOTION_TAG_CLEANUP_REGEX = /\[[a-z]+\]\s*/gi;
-  var EmotionParser = class {
-    /**
-     * Extract emotion from text and return clean text
-     * @param text Text that may contain emotion tags like [happy]
-     * @returns Object containing extracted emotion and clean text
-     */
-    static extractEmotion(text) {
-      const match = text.match(EMOTION_TAG_REGEX);
-      if (match) {
-        const emotion = match[1].toLowerCase();
-        const cleanText = text.replace(EMOTION_TAG_CLEANUP_REGEX, "").trim();
-        return {
-          emotion,
-          cleanText
-        };
-      }
-      return { cleanText: text };
-    }
-    /**
-     * Check if an emotion is valid
-     * @param emotion Emotion string to validate
-     * @returns True if the emotion is valid
-     */
-    static isValidEmotion(emotion) {
-      return emotions.includes(emotion);
-    }
-    /**
-     * Remove all emotion tags from text
-     * @param text Text containing emotion tags
-     * @returns Clean text without emotion tags
-     */
-    static cleanEmotionTags(text) {
-      return text.replace(EMOTION_TAG_CLEANUP_REGEX, "").trim();
-    }
-    /**
-     * Add emotion tag to text
-     * @param emotion Emotion to add
-     * @param text Text content
-     * @returns Text with emotion tag prepended
-     */
-    static addEmotionTag(emotion, text) {
-      return `[${emotion}] ${text}`;
-    }
-  };
-
-  // src/utils/screenplay.ts
-  function textToScreenplay(text) {
-    const { emotion, cleanText } = EmotionParser.extractEmotion(text);
-    if (emotion) {
-      return {
-        emotion,
-        text: cleanText
-      };
-    }
-    return { text: cleanText };
-  }
-  function textsToScreenplay(texts) {
-    return texts.map((text) => textToScreenplay(text));
-  }
-  function screenplayToText(screenplay) {
-    if (screenplay.emotion) {
-      return EmotionParser.addEmotionTag(screenplay.emotion, screenplay.text);
-    }
-    return screenplay.text;
-  }
-
-  // src/utils/runOnce.ts
-  async function runOnceText(chat, messages) {
-    const { blocks } = await chat.chatOnce(messages, false, () => {
-    });
-    return StreamTextAccumulator.getFullText(blocks);
-  }
+  DEFAULT_CHAT_SERVICE_PROVIDERS.forEach(
+    (provider) => ChatServiceFactory.registerProvider(provider)
+  );
 
   // src/adapters/gasFetch.ts
   function installGASFetch() {