@aituber-onair/chat 0.3.0 → 0.4.0

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

@@ -0,0 +1,2997 @@
+"use strict";
+var AITuberOnAirChat = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    CHAT_RESPONSE_LENGTH: () => CHAT_RESPONSE_LENGTH,
+    CLAUDE_VISION_SUPPORTED_MODELS: () => CLAUDE_VISION_SUPPORTED_MODELS,
+    ChatServiceFactory: () => ChatServiceFactory,
+    ChatServiceHttpClient: () => ChatServiceHttpClient,
+    ClaudeChatService: () => ClaudeChatService,
+    ClaudeChatServiceProvider: () => ClaudeChatServiceProvider,
+    DEFAULT_MAX_TOKENS: () => DEFAULT_MAX_TOKENS,
+    DEFAULT_SUMMARY_PROMPT_TEMPLATE: () => DEFAULT_SUMMARY_PROMPT_TEMPLATE,
+    DEFAULT_VISION_PROMPT: () => DEFAULT_VISION_PROMPT,
+    EMOTION_TAG_CLEANUP_REGEX: () => EMOTION_TAG_CLEANUP_REGEX,
+    EMOTION_TAG_REGEX: () => EMOTION_TAG_REGEX,
+    ENDPOINT_CLAUDE_API: () => ENDPOINT_CLAUDE_API,
+    ENDPOINT_GEMINI_API: () => ENDPOINT_GEMINI_API,
+    ENDPOINT_OPENAI_CHAT_COMPLETIONS_API: () => ENDPOINT_OPENAI_CHAT_COMPLETIONS_API,
+    ENDPOINT_OPENAI_RESPONSES_API: () => ENDPOINT_OPENAI_RESPONSES_API,
+    ENDPOINT_OPENROUTER_API: () => ENDPOINT_OPENROUTER_API,
+    EmotionParser: () => EmotionParser,
+    GEMINI_VISION_SUPPORTED_MODELS: () => GEMINI_VISION_SUPPORTED_MODELS,
+    GPT5_PRESETS: () => GPT5_PRESETS,
+    GPT_5_MODELS: () => GPT_5_MODELS,
+    GeminiChatService: () => GeminiChatService,
+    GeminiChatServiceProvider: () => GeminiChatServiceProvider,
+    HttpError: () => HttpError,
+    MAX_TOKENS_BY_LENGTH: () => MAX_TOKENS_BY_LENGTH,
+    MODEL_CLAUDE_3_5_HAIKU: () => MODEL_CLAUDE_3_5_HAIKU,
+    MODEL_CLAUDE_3_5_SONNET: () => MODEL_CLAUDE_3_5_SONNET,
+    MODEL_CLAUDE_3_7_SONNET: () => MODEL_CLAUDE_3_7_SONNET,
+    MODEL_CLAUDE_3_HAIKU: () => MODEL_CLAUDE_3_HAIKU,
+    MODEL_CLAUDE_4_OPUS: () => MODEL_CLAUDE_4_OPUS,
+    MODEL_CLAUDE_4_SONNET: () => MODEL_CLAUDE_4_SONNET,
+    MODEL_GEMINI_1_5_FLASH: () => MODEL_GEMINI_1_5_FLASH,
+    MODEL_GEMINI_1_5_PRO: () => MODEL_GEMINI_1_5_PRO,
+    MODEL_GEMINI_2_0_FLASH: () => MODEL_GEMINI_2_0_FLASH,
+    MODEL_GEMINI_2_0_FLASH_LITE: () => MODEL_GEMINI_2_0_FLASH_LITE,
+    MODEL_GEMINI_2_5_FLASH: () => MODEL_GEMINI_2_5_FLASH,
+    MODEL_GEMINI_2_5_FLASH_LITE: () => MODEL_GEMINI_2_5_FLASH_LITE,
+    MODEL_GEMINI_2_5_FLASH_LITE_PREVIEW_06_17: () => MODEL_GEMINI_2_5_FLASH_LITE_PREVIEW_06_17,
+    MODEL_GEMINI_2_5_PRO: () => MODEL_GEMINI_2_5_PRO,
+    MODEL_GPT_4O: () => MODEL_GPT_4O,
+    MODEL_GPT_4O_MINI: () => MODEL_GPT_4O_MINI,
+    MODEL_GPT_4_1: () => MODEL_GPT_4_1,
+    MODEL_GPT_4_1_MINI: () => MODEL_GPT_4_1_MINI,
+    MODEL_GPT_4_1_NANO: () => MODEL_GPT_4_1_NANO,
+    MODEL_GPT_4_5_PREVIEW: () => MODEL_GPT_4_5_PREVIEW,
+    MODEL_GPT_5: () => MODEL_GPT_5,
+    MODEL_GPT_5_CHAT_LATEST: () => MODEL_GPT_5_CHAT_LATEST,
+    MODEL_GPT_5_MINI: () => MODEL_GPT_5_MINI,
+    MODEL_GPT_5_NANO: () => MODEL_GPT_5_NANO,
+    MODEL_GPT_OSS_20B_FREE: () => MODEL_GPT_OSS_20B_FREE,
+    MODEL_O1: () => MODEL_O1,
+    MODEL_O1_MINI: () => MODEL_O1_MINI,
+    MODEL_O3_MINI: () => MODEL_O3_MINI,
+    OPENROUTER_CREDITS_THRESHOLD: () => OPENROUTER_CREDITS_THRESHOLD,
+    OPENROUTER_FREE_DAILY_LIMIT_HIGH_CREDITS: () => OPENROUTER_FREE_DAILY_LIMIT_HIGH_CREDITS,
+    OPENROUTER_FREE_DAILY_LIMIT_LOW_CREDITS: () => OPENROUTER_FREE_DAILY_LIMIT_LOW_CREDITS,
+    OPENROUTER_FREE_MODELS: () => OPENROUTER_FREE_MODELS,
+    OPENROUTER_FREE_RATE_LIMIT_PER_MINUTE: () => OPENROUTER_FREE_RATE_LIMIT_PER_MINUTE,
+    OPENROUTER_VISION_SUPPORTED_MODELS: () => OPENROUTER_VISION_SUPPORTED_MODELS,
+    OpenAIChatService: () => OpenAIChatService,
+    OpenAIChatServiceProvider: () => OpenAIChatServiceProvider,
+    OpenRouterChatService: () => OpenRouterChatService,
+    OpenRouterChatServiceProvider: () => OpenRouterChatServiceProvider,
+    StreamTextAccumulator: () => StreamTextAccumulator,
+    VISION_SUPPORTED_MODELS: () => VISION_SUPPORTED_MODELS,
+    getMaxTokensForResponseLength: () => getMaxTokensForResponseLength,
+    installGASFetch: () => installGASFetch,
+    isGPT5Model: () => isGPT5Model,
+    isOpenRouterFreeModel: () => isOpenRouterFreeModel,
+    isOpenRouterVisionModel: () => isOpenRouterVisionModel,
+    runOnceText: () => runOnceText,
+    screenplayToText: () => screenplayToText,
+    textToScreenplay: () => textToScreenplay,
+    textsToScreenplay: () => textsToScreenplay
+  });
+
+  // src/constants/openai.ts
+  var ENDPOINT_OPENAI_CHAT_COMPLETIONS_API = "https://api.openai.com/v1/chat/completions";
+  var ENDPOINT_OPENAI_RESPONSES_API = "https://api.openai.com/v1/responses";
+  var MODEL_GPT_5_NANO = "gpt-5-nano";
+  var MODEL_GPT_5_MINI = "gpt-5-mini";
+  var MODEL_GPT_5 = "gpt-5";
+  var MODEL_GPT_5_CHAT_LATEST = "gpt-5-chat-latest";
+  var MODEL_GPT_4_1 = "gpt-4.1";
+  var MODEL_GPT_4_1_MINI = "gpt-4.1-mini";
+  var MODEL_GPT_4_1_NANO = "gpt-4.1-nano";
+  var MODEL_GPT_4O_MINI = "gpt-4o-mini";
+  var MODEL_GPT_4O = "gpt-4o";
+  var MODEL_O3_MINI = "o3-mini";
+  var MODEL_O1_MINI = "o1-mini";
+  var MODEL_O1 = "o1";
+  var MODEL_GPT_4_5_PREVIEW = "gpt-4.5-preview";
+  var VISION_SUPPORTED_MODELS = [
+    MODEL_GPT_5_NANO,
+    MODEL_GPT_5_MINI,
+    MODEL_GPT_5,
+    MODEL_GPT_5_CHAT_LATEST,
+    MODEL_GPT_4_1,
+    MODEL_GPT_4_1_MINI,
+    MODEL_GPT_4_1_NANO,
+    MODEL_GPT_4O_MINI,
+    MODEL_GPT_4O,
+    MODEL_GPT_4_5_PREVIEW,
+    MODEL_O1
+    // MODEL_O3_MINI and MODEL_O1_MINI are not included as they don't support vision
+  ];
+  var GPT_5_MODELS = [
+    MODEL_GPT_5_NANO,
+    MODEL_GPT_5_MINI,
+    MODEL_GPT_5,
+    MODEL_GPT_5_CHAT_LATEST
+  ];
+  function isGPT5Model(model) {
+    return GPT_5_MODELS.includes(model);
+  }
+
+  // src/constants/gemini.ts
+  var ENDPOINT_GEMINI_API = "https://generativelanguage.googleapis.com";
+  var MODEL_GEMINI_2_5_PRO = "gemini-2.5-pro";
+  var MODEL_GEMINI_2_5_FLASH = "gemini-2.5-flash";
+  var MODEL_GEMINI_2_5_FLASH_LITE = "gemini-2.5-flash-lite";
+  var MODEL_GEMINI_2_5_FLASH_LITE_PREVIEW_06_17 = "gemini-2.5-flash-lite-preview-06-17";
+  var MODEL_GEMINI_2_0_FLASH = "gemini-2.0-flash";
+  var MODEL_GEMINI_2_0_FLASH_LITE = "gemini-2.0-flash-lite";
+  var MODEL_GEMINI_1_5_FLASH = "gemini-1.5-flash";
+  var MODEL_GEMINI_1_5_PRO = "gemini-1.5-pro";
+  var GEMINI_VISION_SUPPORTED_MODELS = [
+    MODEL_GEMINI_2_5_PRO,
+    MODEL_GEMINI_2_5_FLASH,
+    MODEL_GEMINI_2_5_FLASH_LITE,
+    MODEL_GEMINI_2_5_FLASH_LITE_PREVIEW_06_17,
+    MODEL_GEMINI_2_0_FLASH,
+    MODEL_GEMINI_2_0_FLASH_LITE,
+    MODEL_GEMINI_1_5_FLASH,
+    MODEL_GEMINI_1_5_PRO
+  ];
+
+  // src/constants/claude.ts
+  var ENDPOINT_CLAUDE_API = "https://api.anthropic.com/v1/messages";
+  var MODEL_CLAUDE_3_HAIKU = "claude-3-haiku-20240307";
+  var MODEL_CLAUDE_3_5_HAIKU = "claude-3-5-haiku-20241022";
+  var MODEL_CLAUDE_3_5_SONNET = "claude-3-5-sonnet-20241022";
+  var MODEL_CLAUDE_3_7_SONNET = "claude-3-7-sonnet-20250219";
+  var MODEL_CLAUDE_4_SONNET = "claude-4-sonnet-20250514";
+  var MODEL_CLAUDE_4_OPUS = "claude-4-opus-20250514";
+  var CLAUDE_VISION_SUPPORTED_MODELS = [
+    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
+  ];
+
+  // src/constants/openrouter.ts
+  var ENDPOINT_OPENROUTER_API = "https://openrouter.ai/api/v1/chat/completions";
+  var MODEL_GPT_OSS_20B_FREE = "openai/gpt-oss-20b:free";
+  var OPENROUTER_FREE_MODELS = [MODEL_GPT_OSS_20B_FREE];
+  var OPENROUTER_VISION_SUPPORTED_MODELS = [];
+  var OPENROUTER_FREE_RATE_LIMIT_PER_MINUTE = 20;
+  var OPENROUTER_FREE_DAILY_LIMIT_LOW_CREDITS = 50;
+  var OPENROUTER_FREE_DAILY_LIMIT_HIGH_CREDITS = 1e3;
+  var OPENROUTER_CREDITS_THRESHOLD = 10;
+  function isOpenRouterFreeModel(model) {
+    return OPENROUTER_FREE_MODELS.some((freeModel) => model.includes(freeModel));
+  }
+  function isOpenRouterVisionModel(model) {
+    return OPENROUTER_VISION_SUPPORTED_MODELS.some(
+      (visionModel) => model.includes(visionModel)
+    );
+  }
+
+  // src/constants/chat.ts
+  var CHAT_RESPONSE_LENGTH = {
+    VERY_SHORT: "veryShort",
+    SHORT: "short",
+    MEDIUM: "medium",
+    LONG: "long",
+    VERY_LONG: "veryLong",
+    // Extended response length for longer outputs
+    DEEP: "deep"
+  };
+  var MAX_TOKENS_BY_LENGTH = {
+    [CHAT_RESPONSE_LENGTH.VERY_SHORT]: 40,
+    [CHAT_RESPONSE_LENGTH.SHORT]: 100,
+    [CHAT_RESPONSE_LENGTH.MEDIUM]: 200,
+    [CHAT_RESPONSE_LENGTH.LONG]: 300,
+    [CHAT_RESPONSE_LENGTH.VERY_LONG]: 1e3,
+    // Extended response length for longer outputs
+    [CHAT_RESPONSE_LENGTH.DEEP]: 5e3
+  };
+  var DEFAULT_MAX_TOKENS = 5e3;
+  var GPT5_PRESETS = {
+    casual: {
+      reasoning_effort: "minimal",
+      verbosity: "low",
+      description: "Fast responses for casual chat, quick questions (GPT-4 like experience)"
+    },
+    balanced: {
+      reasoning_effort: "medium",
+      verbosity: "medium",
+      description: "Balanced reasoning for business tasks, learning, general problem solving"
+    },
+    expert: {
+      reasoning_effort: "high",
+      verbosity: "high",
+      description: "Deep reasoning for research, complex analysis, expert-level tasks"
+    }
+  };
+  function getMaxTokensForResponseLength(responseLength) {
+    if (!responseLength) {
+      return DEFAULT_MAX_TOKENS;
+    }
+    return MAX_TOKENS_BY_LENGTH[responseLength] ?? DEFAULT_MAX_TOKENS;
+  }
+
+  // src/constants/prompts.ts
+  var DEFAULT_VISION_PROMPT = "You are a friendly AI avatar. Comment on the situation based on the broadcast screen.";
+  var DEFAULT_SUMMARY_PROMPT_TEMPLATE = `You are a skilled summarizing assistant. 
+Analyze the following conversation and produce a summary in the **same language** as the majority of the conversation:
+- Summaries should highlight key points
+- Stay concise (around {maxLength} characters if possible)
+- No redundant expressions
+
+If the conversation is in Japanese, summarize in Japanese.
+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) {
+      super(`HTTP ${status}: ${statusText}`);
+      this.status = status;
+      this.statusText = statusText;
+      this.body = body;
+      this.name = "HttpError";
+    }
+  };
+  var _ChatServiceHttpClient = class _ChatServiceHttpClient {
+    /**
+     * Set custom fetch implementation
+     */
+    static setFetch(fn) {
+      this.fetchImpl = fn;
+    }
+    /**
+     * Make a POST request with common error handling
+     * @param url Request URL
+     * @param body Request body
+     * @param headers Request headers
+     * @param options Additional options
+     * @returns Response object
+     */
+    static async post(url, body, headers = {}, options = {}) {
+      const { timeout = 3e4, retries = 0, retryDelay = 1e3 } = options;
+      const defaultHeaders = {
+        "Content-Type": "application/json"
+      };
+      const finalHeaders = { ...defaultHeaders, ...headers };
+      let lastError = null;
+      for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+          const hasAbort = typeof AbortController !== "undefined";
+          const controller = hasAbort ? new AbortController() : void 0;
+          const timeoutId = hasAbort ? setTimeout(() => controller.abort(), timeout) : void 0;
+          const response = await _ChatServiceHttpClient.fetchImpl(url, {
+            method: "POST",
+            headers: finalHeaders,
+            body: typeof body === "string" ? body : JSON.stringify(body),
+            // Attach signal only when controller exists
+            ...controller ? { signal: controller.signal } : {}
+          });
+          if (timeoutId) clearTimeout(timeoutId);
+          if (!response.ok) {
+            const errorBody = await response.text();
+            throw new HttpError(response.status, response.statusText, errorBody);
+          }
+          return response;
+        } catch (error) {
+          lastError = error;
+          if (error instanceof HttpError && error.status >= 400 && error.status < 500) {
+            throw error;
+          }
+          if (error instanceof Error && error.name === "AbortError") {
+            throw new Error(`Request timeout after ${timeout}ms`);
+          }
+          if (attempt < retries) {
+            await new Promise(
+              (resolve) => setTimeout(resolve, retryDelay * (attempt + 1))
+            );
+          }
+        }
+      }
+      throw lastError || new Error("Request failed");
+    }
+    /**
+     * Handle error response and throw appropriate error
+     * @param res Response object
+     * @returns Never (always throws)
+     */
+    static async handleErrorResponse(res) {
+      const errorBody = await res.text();
+      throw new HttpError(res.status, res.statusText, errorBody);
+    }
+    /**
+     * Make a GET request (for fetching images, etc.)
+     * @param url Request URL
+     * @param headers Request headers
+     * @param options Additional options
+     * @returns Response object
+     */
+    static async get(url, headers = {}, options = {}) {
+      const { timeout = 3e4, retries = 0, retryDelay = 1e3 } = options;
+      let lastError = null;
+      for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+          const hasAbort = typeof AbortController !== "undefined";
+          const controller = hasAbort ? new AbortController() : void 0;
+          const timeoutId = hasAbort ? setTimeout(() => controller.abort(), timeout) : void 0;
+          const response = await _ChatServiceHttpClient.fetchImpl(url, {
+            method: "GET",
+            headers,
+            ...controller ? { signal: controller.signal } : {}
+          });
+          if (timeoutId) clearTimeout(timeoutId);
+          if (!response.ok) {
+            const errorBody = await response.text();
+            throw new HttpError(response.status, response.statusText, errorBody);
+          }
+          return response;
+        } catch (error) {
+          lastError = error;
+          if (error instanceof HttpError && error.status >= 400 && error.status < 500) {
+            throw error;
+          }
+          if (error instanceof Error && error.name === "AbortError") {
+            throw new Error(`Request timeout after ${timeout}ms`);
+          }
+          if (attempt < retries) {
+            await new Promise(
+              (resolve) => setTimeout(resolve, retryDelay * (attempt + 1))
+            );
+          }
+        }
+      }
+      throw lastError || new Error("Request failed");
+    }
+  };
+  /**
+   * Injectable fetch implementation (browser/node: native fetch, GAS: UrlFetchApp wrapper)
+   */
+  _ChatServiceHttpClient.fetchImpl = (u, i) => fetch(u, i);
+  var ChatServiceHttpClient = _ChatServiceHttpClient;
+
+  // src/services/providers/openai/OpenAIChatService.ts
+  var OpenAIChatService = class {
+    /**
+     * Constructor
+     * @param apiKey OpenAI API key
+     * @param model Name of the model to use
+     * @param visionModel Name of the vision model
+     */
+    constructor(apiKey, model = MODEL_GPT_4O_MINI, visionModel = MODEL_GPT_4O_MINI, tools, endpoint = ENDPOINT_OPENAI_CHAT_COMPLETIONS_API, mcpServers = [], responseLength, verbosity, reasoning_effort, enableReasoningSummary = false) {
+      /** Provider name */
+      this.provider = "openai";
+      this.apiKey = apiKey;
+      this.model = model;
+      this.tools = tools || [];
+      this.endpoint = endpoint;
+      this.mcpServers = mcpServers;
+      this.responseLength = responseLength;
+      this.verbosity = verbosity;
+      this.reasoning_effort = reasoning_effort;
+      this.enableReasoningSummary = enableReasoningSummary;
+      if (!VISION_SUPPORTED_MODELS.includes(visionModel)) {
+        throw new Error(
+          `Model ${visionModel} does not support vision capabilities.`
+        );
+      }
+      this.visionModel = visionModel;
+    }
+    /**
+     * Get the current model name
+     * @returns Model name
+     */
+    getModel() {
+      return this.model;
+    }
+    /**
+     * Get the current vision model name
+     * @returns Vision model name
+     */
+    getVisionModel() {
+      return this.visionModel;
+    }
+    /**
+     * Process chat messages
+     * @param messages Array of messages to send
+     * @param onPartialResponse Callback to receive each part of streaming response
+     * @param onCompleteResponse Callback to execute when response is complete
+     */
+    async processChat(messages, onPartialResponse, onCompleteResponse) {
+      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."
+      );
+    }
+    /**
+     * 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}`
+      });
+      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
+     */
+    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
+              };
+            }
+            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) {
+        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());
+      }
+      return toolDefs;
+    }
+    /**
+     * 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.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) {
+      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;
+          }
+        }
+      }
+      return full;
+    }
+    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 });
+        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 });
+          }
+          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"
+      };
+    }
+    parseOneShot(data) {
+      const choice = data.choices[0];
+      const blocks = [];
+      if (choice.finish_reason === "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 {
+        blocks.push({ type: "text", text: choice.message.content });
+      }
+      return {
+        blocks,
+        stop_reason: choice.finish_reason === "tool_calls" ? "tool_use" : "end"
+      };
+    }
+    /**
+     * Parse streaming response from Responses API (SSE format)
+     */
+    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"
+      };
+    }
+    /**
+     * 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 from Responses API
+     */
+    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) : {}
+            });
+          }
+        });
+      }
+      return {
+        blocks,
+        stop_reason: blocks.some((b) => b.type === "tool_use") ? "tool_use" : "end"
+      };
+    }
+  };
+
+  // src/services/providers/openai/OpenAIChatServiceProvider.ts
+  var OpenAIChatServiceProvider = class {
+    /**
+     * Create a chat service instance
+     * @param options Service options
+     * @returns OpenAIChatService 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,
+        visionModel,
+        tools,
+        endpoint,
+        mcpServers,
+        optimizedOptions.responseLength,
+        optimizedOptions.verbosity,
+        optimizedOptions.reasoning_effort,
+        optimizedOptions.enableReasoningSummary
+      );
+    }
+    /**
+     * Get the provider name
+     * @returns Provider name ('openai')
+     */
+    getProviderName() {
+      return "openai";
+    }
+    /**
+     * Get the list of supported models
+     * @returns Array of supported model names
+     */
+    getSupportedModels() {
+      return [
+        MODEL_GPT_5_NANO,
+        MODEL_GPT_5_MINI,
+        MODEL_GPT_5,
+        MODEL_GPT_5_CHAT_LATEST,
+        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
+     */
+    getDefaultModel() {
+      return MODEL_GPT_5_NANO;
+    }
+    /**
+     * Check if this provider supports vision (image processing)
+     * @returns Vision support status (true)
+     */
+    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 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 = "medium";
+        }
+      }
+      return optimized;
+    }
+  };
+
+  // src/utils/mcpSchemaFetcher.ts
+  var MCPSchemaFetcher = class {
+    /**
+     * Fetch tool schemas from MCP server
+     * @param serverConfig MCP server configuration
+     * @returns Array of tool definitions
+     */
+    static async fetchToolSchemas(serverConfig) {
+      try {
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (serverConfig.authorization_token) {
+          headers["Authorization"] = `Bearer ${serverConfig.authorization_token}`;
+        }
+        const response = await ChatServiceHttpClient.post(
+          `${serverConfig.url}/tools`,
+          {},
+          headers
+        );
+        const toolsData = await response.json();
+        if (Array.isArray(toolsData.tools)) {
+          return toolsData.tools.map((tool) => ({
+            name: `mcp_${serverConfig.name}_${tool.name}`,
+            description: tool.description || `Tool from ${serverConfig.name} MCP server`,
+            parameters: tool.inputSchema || {
+              type: "object",
+              properties: {},
+              required: []
+            }
+          }));
+        }
+        return [
+          {
+            name: `mcp_${serverConfig.name}_search`,
+            description: `Search using ${serverConfig.name} MCP server`,
+            parameters: {
+              type: "object",
+              properties: {
+                query: {
+                  type: "string",
+                  description: "Search query"
+                }
+              },
+              required: ["query"]
+            }
+          }
+        ];
+      } catch (error) {
+        console.warn(
+          `Failed to fetch MCP schemas from ${serverConfig.name}:`,
+          error
+        );
+        return [
+          {
+            name: `mcp_${serverConfig.name}_search`,
+            description: `Search using ${serverConfig.name} MCP server (schema fetch failed)`,
+            parameters: {
+              type: "object",
+              properties: {
+                query: {
+                  type: "string",
+                  description: "Search query"
+                }
+              },
+              required: ["query"]
+            }
+          }
+        ];
+      }
+    }
+    /**
+     * Fetch all tool schemas from multiple MCP servers
+     * @param mcpServers Array of MCP server configurations
+     * @returns Array of all tool definitions
+     */
+    static async fetchAllToolSchemas(mcpServers) {
+      const allSchemas = [];
+      for (const server of mcpServers) {
+        try {
+          const schemas = await this.fetchToolSchemas(server);
+          allSchemas.push(...schemas);
+        } catch (error) {
+          console.error(`Failed to fetch schemas from ${server.name}:`, error);
+        }
+      }
+      return allSchemas;
+    }
+  };
+
+  // src/services/providers/gemini/GeminiChatService.ts
+  var GeminiChatService = class {
+    /**
+     * Constructor
+     * @param apiKey Google API key
+     * @param model Name of the model to use
+     * @param visionModel Name of the vision model
+     * @param tools Array of tool definitions
+     * @param mcpServers Array of MCP server configurations
+     */
+    constructor(apiKey, model = MODEL_GEMINI_2_0_FLASH_LITE, visionModel = MODEL_GEMINI_2_0_FLASH_LITE, tools = [], mcpServers = [], responseLength) {
+      /** Provider name */
+      this.provider = "gemini";
+      this.mcpToolSchemas = [];
+      this.mcpSchemasInitialized = false;
+      /** id(OpenAI) → name(Gemini) mapping */
+      this.callIdMap = /* @__PURE__ */ new Map();
+      this.apiKey = apiKey;
+      this.model = model;
+      this.responseLength = responseLength;
+      if (!GEMINI_VISION_SUPPORTED_MODELS.includes(visionModel)) {
+        throw new Error(
+          `Model ${visionModel} does not support vision capabilities.`
+        );
+      }
+      this.visionModel = visionModel;
+      this.tools = tools;
+      this.mcpServers = mcpServers;
+    }
+    /* ────────────────────────────────── */
+    /*  Utilities                           */
+    /* ────────────────────────────────── */
+    safeJsonParse(str) {
+      try {
+        return JSON.parse(str);
+      } catch {
+        return str;
+      }
+    }
+    normalizeToolResult(val) {
+      if (val === null) return { content: null };
+      if (typeof val === "object") return val;
+      return { content: val };
+    }
+    /**
+     * camelCase → snake_case conversion (v1beta)
+     */
+    adaptKeysForApi(obj) {
+      const map = {
+        toolConfig: "tool_config",
+        functionCallingConfig: "function_calling_config",
+        functionDeclarations: "function_declarations",
+        functionCall: "function_call",
+        functionResponse: "function_response"
+      };
+      if (Array.isArray(obj)) return obj.map((v) => this.adaptKeysForApi(v));
+      if (obj && typeof obj === "object") {
+        return Object.fromEntries(
+          Object.entries(obj).map(([k, v]) => [
+            map[k] ?? k,
+            this.adaptKeysForApi(v)
+          ])
+        );
+      }
+      return obj;
+    }
+    /**
+     * Get the current model name
+     * @returns Model name
+     */
+    getModel() {
+      return this.model;
+    }
+    /**
+     * Get the current vision model name
+     * @returns Vision model name
+     */
+    getVisionModel() {
+      return this.visionModel;
+    }
+    /**
+     * Get configured MCP servers
+     * @returns Array of MCP server configurations
+     */
+    getMCPServers() {
+      return this.mcpServers;
+    }
+    /**
+     * Add MCP server configuration
+     * @param serverConfig MCP server configuration
+     */
+    addMCPServer(serverConfig) {
+      this.mcpServers.push(serverConfig);
+      this.mcpSchemasInitialized = false;
+    }
+    /**
+     * Remove MCP server by name
+     * @param serverName Name of the server to remove
+     */
+    removeMCPServer(serverName) {
+      this.mcpServers = this.mcpServers.filter(
+        (server) => server.name !== serverName
+      );
+      this.mcpSchemasInitialized = false;
+    }
+    /**
+     * Check if MCP servers are configured
+     * @returns True if MCP servers are configured
+     */
+    hasMCPServers() {
+      return this.mcpServers.length > 0;
+    }
+    /**
+     * Initialize MCP tool schemas by fetching from servers
+     * @private
+     */
+    async initializeMCPSchemas() {
+      if (this.mcpSchemasInitialized || this.mcpServers.length === 0) {
+        return;
+      }
+      try {
+        const timeoutPromise = new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("MCP schema fetch timeout")), 5e3)
+        );
+        const schemasPromise = MCPSchemaFetcher.fetchAllToolSchemas(
+          this.mcpServers
+        );
+        this.mcpToolSchemas = await Promise.race([
+          schemasPromise,
+          timeoutPromise
+        ]);
+        this.mcpSchemasInitialized = true;
+      } catch (error) {
+        console.warn("Failed to initialize MCP schemas, using fallback:", error);
+        this.mcpToolSchemas = this.mcpServers.map((server) => ({
+          name: `mcp_${server.name}_search`,
+          description: `Search using ${server.name} MCP server (fallback)`,
+          parameters: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: "Search query"
+              }
+            },
+            required: ["query"]
+          }
+        }));
+        this.mcpSchemasInitialized = true;
+      }
+    }
+    /**
+     * Process chat messages
+     * @param messages Array of messages to send
+     * @param onPartialResponse Callback to receive each part of streaming response
+     * @param onCompleteResponse Callback to execute when response is complete
+     */
+    async processChat(messages, onPartialResponse, onCompleteResponse) {
+      try {
+        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."
+        );
+      } catch (err) {
+        console.error("Error in processChat:", err);
+        throw err;
+      }
+    }
+    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."
+        );
+      } catch (err) {
+        console.error("Error in processVisionChat:", err);
+        throw err;
+      }
+    }
+    /* ────────────────────────────────── */
+    /*  OpenAI → Gemini conversion         */
+    /* ────────────────────────────────── */
+    convertMessagesToGeminiFormat(messages) {
+      const gemini = [];
+      let currentRole = null;
+      let currentParts = [];
+      const pushCurrent = () => {
+        if (currentRole && currentParts.length) {
+          gemini.push({ role: currentRole, parts: [...currentParts] });
+          currentParts = [];
+        }
+      };
+      for (const msg of messages) {
+        const role = this.mapRoleToGemini(msg.role);
+        if (msg.tool_calls) {
+          pushCurrent();
+          for (const call of msg.tool_calls) {
+            this.callIdMap.set(call.id, call.function.name);
+            gemini.push({
+              role: "model",
+              parts: [
+                {
+                  functionCall: {
+                    name: call.function.name,
+                    args: JSON.parse(call.function.arguments || "{}")
+                  }
+                }
+              ]
+            });
+          }
+          continue;
+        }
+        if (msg.role === "tool") {
+          pushCurrent();
+          const funcName = msg.name ?? this.callIdMap.get(msg.tool_call_id) ?? "result";
+          gemini.push({
+            role: "user",
+            parts: [
+              {
+                functionResponse: {
+                  name: funcName,
+                  response: this.normalizeToolResult(
+                    this.safeJsonParse(msg.content)
+                  )
+                }
+              }
+            ]
+          });
+          continue;
+        }
+        if (role !== currentRole) pushCurrent();
+        currentRole = role;
+        currentParts.push({ text: msg.content });
+      }
+      pushCurrent();
+      return gemini;
+    }
+    /* ────────────────────────────────── */
+    /*  HTTP call                           */
+    /* ────────────────────────────────── */
+    async callGemini(messages, model, stream = false, maxTokens) {
+      const hasVision = messages.some(
+        (m) => Array.isArray(m.content) && m.content.some(
+          (b) => b?.type === "image_url" || b?.inlineData
+        )
+      );
+      const contents = hasVision ? await this.convertVisionMessagesToGeminiFormat(
+        messages
+      ) : this.convertMessagesToGeminiFormat(messages);
+      const body = {
+        contents,
+        generationConfig: {
+          maxOutputTokens: maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength)
+        }
+      };
+      const allToolDeclarations = [];
+      if (this.tools.length > 0) {
+        allToolDeclarations.push(
+          ...this.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters
+          }))
+        );
+      }
+      if (this.mcpServers.length > 0) {
+        try {
+          await this.initializeMCPSchemas();
+          allToolDeclarations.push(
+            ...this.mcpToolSchemas.map((t) => ({
+              name: t.name,
+              description: t.description,
+              parameters: t.parameters
+            }))
+          );
+        } catch (error) {
+          console.warn("MCP initialization failed, skipping MCP tools:", error);
+        }
+      }
+      if (allToolDeclarations.length > 0) {
+        body.tools = [
+          {
+            functionDeclarations: allToolDeclarations
+          }
+        ];
+        body.toolConfig = { functionCallingConfig: { mode: "AUTO" } };
+      }
+      const fetchOnce = async (ver, payload) => {
+        const fn = stream ? "streamGenerateContent" : "generateContent";
+        const alt = stream ? "?alt=sse" : "";
+        const url = `${ENDPOINT_GEMINI_API}/${ver}/models/${model}:${fn}${alt}${alt ? "&" : "?"}key=${this.apiKey}`;
+        return ChatServiceHttpClient.post(url, payload);
+      };
+      const isLite = /flash[-_]lite/.test(model);
+      const isGemini25 = /gemini-2\.5/.test(model);
+      const firstVer = isLite || isGemini25 ? "v1beta" : "v1";
+      const tryApi = async () => {
+        try {
+          const payload = firstVer === "v1" ? body : this.adaptKeysForApi(body);
+          return await fetchOnce(firstVer, payload);
+        } catch (e) {
+          if (!(isLite || isGemini25) && /Unknown name|Cannot find field|404/.test(e.message)) {
+            return await fetchOnce("v1beta", this.adaptKeysForApi(body));
+          }
+          throw e;
+        }
+      };
+      try {
+        const res = await tryApi();
+        return res;
+      } catch (error) {
+        if (error.body) {
+          console.error("Gemini API Error Details:", error.body);
+          console.error("Request Body:", JSON.stringify(body, null, 2));
+        }
+        throw error;
+      }
+    }
+    /**
+     * Convert AITuber OnAir vision messages to Gemini format
+     * @param messages Array of vision messages
+     * @returns Gemini formatted vision messages
+     */
+    async convertVisionMessagesToGeminiFormat(messages) {
+      const geminiMessages = [];
+      let currentRole = null;
+      let currentParts = [];
+      for (const msg of messages) {
+        const role = this.mapRoleToGemini(msg.role);
+        if (msg.tool_calls) {
+          for (const call of msg.tool_calls) {
+            geminiMessages.push({
+              role: "model",
+              parts: [
+                {
+                  functionCall: {
+                    name: call.function.name,
+                    args: JSON.parse(call.function.arguments || "{}")
+                  }
+                }
+              ]
+            });
+          }
+          continue;
+        }
+        if (msg.role === "tool") {
+          const funcName = msg.name ?? this.callIdMap.get(msg.tool_call_id) ?? "result";
+          geminiMessages.push({
+            role: "user",
+            parts: [
+              {
+                functionResponse: {
+                  name: funcName,
+                  response: this.normalizeToolResult(
+                    this.safeJsonParse(msg.content)
+                  )
+                }
+              }
+            ]
+          });
+          continue;
+        }
+        if (role !== currentRole && currentParts.length > 0) {
+          geminiMessages.push({
+            role: currentRole,
+            parts: [...currentParts]
+          });
+          currentParts = [];
+        }
+        currentRole = role;
+        if (typeof msg.content === "string") {
+          currentParts.push({ text: msg.content });
+        } else if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block.type === "text") {
+              currentParts.push({ text: block.text });
+            } else if (block.type === "image_url") {
+              try {
+                const imageResponse = await ChatServiceHttpClient.get(
+                  block.image_url.url
+                );
+                const imageBlob = await imageResponse.blob();
+                const base64Data = await this.blobToBase64(imageBlob);
+                currentParts.push({
+                  inlineData: {
+                    mimeType: imageBlob.type || "image/jpeg",
+                    data: base64Data.split(",")[1]
+                    // Remove the "data:image/jpeg;base64," prefix
+                  }
+                });
+              } catch (error) {
+                console.error("Error processing image:", error);
+                throw new Error(`Failed to process image: ${error.message}`);
+              }
+            }
+          }
+        }
+      }
+      if (currentRole && currentParts.length > 0) {
+        geminiMessages.push({
+          role: currentRole,
+          parts: [...currentParts]
+        });
+      }
+      return geminiMessages;
+    }
+    /**
+     * Convert Blob to Base64 string
+     * @param blob Image blob
+     * @returns Promise with base64 encoded string
+     */
+    blobToBase64(blob) {
+      return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = () => resolve(reader.result);
+        reader.onerror = reject;
+        reader.readAsDataURL(blob);
+      });
+    }
+    /**
+     * Map AITuber OnAir roles to Gemini roles
+     * @param role AITuber OnAir role
+     * @returns Gemini role
+     */
+    mapRoleToGemini(role) {
+      switch (role) {
+        case "system":
+          return "model";
+        // Gemini uses 'model' for system messages
+        case "user":
+          return "user";
+        case "assistant":
+          return "model";
+        default:
+          return "user";
+      }
+    }
+    /* ────────────────────────────────────────────────────────── */
+    /*  Convert NDJSON stream to common format             */
+    /* ────────────────────────────────────────────────────────── */
+    async parseStream(res, onPartial) {
+      const reader = res.body.getReader();
+      const dec = new TextDecoder();
+      const textBlocks = [];
+      const toolBlocks = [];
+      let buf = "";
+      const flush = (payload) => {
+        if (!payload || payload === "[DONE]") return;
+        let obj;
+        try {
+          obj = JSON.parse(payload);
+        } catch {
+          return;
+        }
+        for (const cand of obj.candidates ?? []) {
+          for (const part of cand.content?.parts ?? []) {
+            if (part.text) {
+              onPartial(part.text);
+              StreamTextAccumulator.addTextBlock(textBlocks, part.text);
+            }
+            if (part.functionCall) {
+              toolBlocks.push({
+                type: "tool_use",
+                id: this.genUUID(),
+                name: part.functionCall.name,
+                input: part.functionCall.args ?? {}
+              });
+            }
+            if (part.functionResponse) {
+              toolBlocks.push({
+                type: "tool_result",
+                tool_use_id: part.functionResponse.name,
+                content: JSON.stringify(part.functionResponse.response)
+              });
+            }
+          }
+        }
+      };
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += dec.decode(value, { stream: true });
+        let nl;
+        while ((nl = buf.indexOf("\n")) !== -1) {
+          let line = buf.slice(0, nl);
+          buf = buf.slice(nl + 1);
+          if (line.endsWith("\r")) line = line.slice(0, -1);
+          if (!line.trim()) {
+            flush("");
+            continue;
+          }
+          if (line.startsWith("data:")) line = line.slice(5).trim();
+          if (!line) continue;
+          flush(line);
+        }
+      }
+      if (buf) flush(buf);
+      const blocks = [...textBlocks, ...toolBlocks];
+      return {
+        blocks,
+        stop_reason: toolBlocks.some((b) => b.type === "tool_use") ? "tool_use" : "end"
+      };
+    }
+    /* ────────────────────────────────────────────────────────── */
+    /*  Convert JSON of non-stream (= generateContent)        */
+    /* ────────────────────────────────────────────────────────── */
+    parseOneShot(data) {
+      const textBlocks = [];
+      const toolBlocks = [];
+      for (const cand of data.candidates ?? []) {
+        for (const part of cand.content?.parts ?? []) {
+          if (part.text) {
+            textBlocks.push({ type: "text", text: part.text });
+          }
+          if (part.functionCall) {
+            toolBlocks.push({
+              type: "tool_use",
+              id: this.genUUID(),
+              name: part.functionCall.name,
+              input: part.functionCall.args ?? {}
+            });
+          }
+          if (part.functionResponse) {
+            toolBlocks.push({
+              type: "tool_result",
+              tool_use_id: part.functionResponse.name,
+              content: JSON.stringify(part.functionResponse.response)
+            });
+          }
+        }
+      }
+      const blocks = [...textBlocks, ...toolBlocks];
+      return {
+        blocks,
+        stop_reason: toolBlocks.some((b) => b.type === "tool_use") ? "tool_use" : "end"
+      };
+    }
+    /* ────────────────────────────────────────────────────────── */
+    /*  chatOnce (text)                                       */
+    /* ────────────────────────────────────────────────────────── */
+    async chatOnce(messages, stream = true, onPartialResponse = () => {
+    }, maxTokens) {
+      const res = await this.callGemini(messages, this.model, stream, maxTokens);
+      return stream ? this.parseStream(res, onPartialResponse) : this.parseOneShot(await res.json());
+    }
+    /* ────────────────────────────────────────────────────────── */
+    /*  visionChatOnce (images)                               */
+    /* ────────────────────────────────────────────────────────── */
+    async visionChatOnce(messages, stream = false, onPartialResponse = () => {
+    }, maxTokens) {
+      const res = await this.callGemini(
+        messages,
+        this.visionModel,
+        stream,
+        maxTokens
+      );
+      return stream ? this.parseStream(res, onPartialResponse) : this.parseOneShot(await res.json());
+    }
+    /* ────────────────────────────────────────────────────────── */
+    /*  UUID helper                                           */
+    /* ────────────────────────────────────────────────────────── */
+    genUUID() {
+      return typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0;
+        const v = c === "x" ? r : r & 3 | 8;
+        return v.toString(16);
+      });
+    }
+  };
+
+  // src/services/providers/gemini/GeminiChatServiceProvider.ts
+  var GeminiChatServiceProvider = class {
+    /**
+     * Create a chat service instance
+     * @param options Service options
+     * @returns GeminiChatService instance
+     */
+    createChatService(options) {
+      const visionModel = options.visionModel || (this.supportsVisionForModel(options.model || this.getDefaultModel()) ? options.model : this.getDefaultModel());
+      return new GeminiChatService(
+        options.apiKey,
+        options.model || this.getDefaultModel(),
+        visionModel,
+        options.tools || [],
+        options.mcpServers || [],
+        options.responseLength
+      );
+    }
+    /**
+     * Get the provider name
+     * @returns Provider name ('gemini')
+     */
+    getProviderName() {
+      return "gemini";
+    }
+    /**
+     * Get the list of supported models
+     * @returns Array of supported model names
+     */
+    getSupportedModels() {
+      return [
+        MODEL_GEMINI_2_5_PRO,
+        MODEL_GEMINI_2_5_FLASH,
+        MODEL_GEMINI_2_5_FLASH_LITE,
+        MODEL_GEMINI_2_5_FLASH_LITE_PREVIEW_06_17,
+        MODEL_GEMINI_2_0_FLASH,
+        MODEL_GEMINI_2_0_FLASH_LITE,
+        MODEL_GEMINI_1_5_FLASH,
+        MODEL_GEMINI_1_5_PRO
+      ];
+    }
+    /**
+     * Get the default model
+     * @returns Default model name
+     */
+    getDefaultModel() {
+      return MODEL_GEMINI_2_0_FLASH_LITE;
+    }
+    /**
+     * Check if this provider supports vision (image processing)
+     * @returns Vision support status (true)
+     */
+    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 GEMINI_VISION_SUPPORTED_MODELS.includes(model);
+    }
+  };
+
+  // src/services/providers/claude/ClaudeChatService.ts
+  var ClaudeChatService = class {
+    /**
+     * Constructor
+     * @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_CLAUDE_3_HAIKU, visionModel = MODEL_CLAUDE_3_HAIKU, tools = [], mcpServers = [], responseLength) {
+      /** Provider name */
+      this.provider = "claude";
+      this.apiKey = apiKey;
+      this.model = model || MODEL_CLAUDE_3_HAIKU;
+      this.visionModel = visionModel || MODEL_CLAUDE_3_HAIKU;
+      this.tools = tools;
+      this.mcpServers = mcpServers;
+      this.responseLength = responseLength;
+      if (!CLAUDE_VISION_SUPPORTED_MODELS.includes(this.visionModel)) {
+        throw new Error(
+          `Model ${this.visionModel} does not support vision capabilities.`
+        );
+      }
+    }
+    /**
+     * 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."
+      );
+    }
+    /**
+     * 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;
+      }
+      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
+        };
+      });
+    }
+    /**
+     * Convert AITuber OnAir vision messages to Claude format
+     * @param messages Array of vision messages
+     * @returns Claude formatted vision messages
+     */
+    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: []
+        };
+      });
+    }
+    /**
+     * Map AITuber OnAir roles to Claude roles
+     * @param role AITuber OnAir role
+     * @returns Claude role
+     */
+    mapRoleToClaude(role) {
+      switch (role) {
+        case "system":
+          return "system";
+        case "user":
+          return "user";
+        case "assistant":
+          return "assistant";
+        default:
+          return "user";
+      }
+    }
+    /**
+     * 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";
+      }
+    }
+    /**
+     * 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";
+      }
+      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);
+          }
+        }
+      }
+      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);
+    }
+    /**
+     * 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
+     */
+    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);
+    }
+    /**
+     * Convert internal completion to standard ToolChatCompletion
+     * @param completion Internal completion result
+     * @returns Standard ToolChatCompletion
+     */
+    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
+      };
+    }
+  };
+
+  // src/services/providers/claude/ClaudeChatServiceProvider.ts
+  var ClaudeChatServiceProvider = 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(
+        options.apiKey,
+        options.model || this.getDefaultModel(),
+        visionModel,
+        options.tools ?? [],
+        options.mcpServers ?? [],
+        options.responseLength
+      );
+    }
+    /**
+     * Get the provider name
+     * @returns Provider name ('claude')
+     */
+    getProviderName() {
+      return "claude";
+    }
+    /**
+     * 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
+      ];
+    }
+    /**
+     * Get the default model
+     * @returns Default model name
+     */
+    getDefaultModel() {
+      return MODEL_CLAUDE_3_HAIKU;
+    }
+    /**
+     * Check if this provider supports vision (image processing)
+     * @returns Vision support status (true)
+     */
+    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);
+    }
+  };
+
+  // src/services/providers/openrouter/OpenRouterChatService.ts
+  var OpenRouterChatService = class {
+    /**
+     * Constructor
+     * @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_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 = "openrouter";
+      this.lastRequestTime = 0;
+      this.requestCount = 0;
+      this.apiKey = apiKey;
+      this.model = model;
+      this.tools = tools || [];
+      this.endpoint = endpoint;
+      this.responseLength = responseLength;
+      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;
+    }
+    /**
+     * 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
+     * @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();
+      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."
+      );
+    }
+    /**
+     * 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 (!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."
+        );
+      } 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) {
+      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 (!isOpenRouterVisionModel(this.visionModel)) {
+        throw new Error(
+          `Model ${this.visionModel} does not support vision capabilities.`
+        );
+      }
+      await this.applyRateLimiting();
+      const res = await this.callOpenRouter(
+        messages,
+        this.visionModel,
+        stream,
+        maxTokens
+      );
+      return stream ? this.parseStream(res, onPartialResponse) : this.parseOneShot(await res.json());
+    }
+    /**
+     * Call OpenRouter API
+     */
+    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;
+      }
+      const res = await ChatServiceHttpClient.post(this.endpoint, body, headers);
+      return res;
+    }
+    /**
+     * Build request body for OpenRouter API (OpenAI-compatible format)
+     */
+    buildRequestBody(messages, model, stream, maxTokens) {
+      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 (this.reasoning_effort || this.includeReasoning !== void 0 || this.reasoningMaxTokens) {
+        body.reasoning = {};
+        if (this.reasoning_effort) {
+          const effort = this.reasoning_effort === "minimal" ? "low" : this.reasoning_effort;
+          body.reasoning.effort = effort;
+        }
+        if (this.includeReasoning !== true) {
+          body.reasoning.exclude = true;
+        }
+        if (this.reasoningMaxTokens) {
+          body.reasoning.max_tokens = this.reasoningMaxTokens;
+        }
+      } else {
+        body.reasoning = { exclude: true };
+      }
+      if (this.tools.length > 0) {
+        body.tools = this.tools.map((t) => ({
+          type: "function",
+          function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters
+          }
+        }));
+        body.tool_choice = "auto";
+      }
+      return body;
+    }
+    /**
+     * 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 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;
+            }
+          } catch (e) {
+            console.debug("Failed to parse SSE data:", jsonStr);
+          }
+        }
+      }
+      return full;
+    }
+    /**
+     * 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"
+      };
+    }
+    /**
+     * Parse non-streaming response
+     */
+    parseOneShot(data) {
+      const choice = data.choices?.[0];
+      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 });
+      }
+      return {
+        blocks,
+        stop_reason: choice?.finish_reason === "tool_calls" ? "tool_use" : "end"
+      };
+    }
+  };
+
+  // src/services/providers/openrouter/OpenRouterChatServiceProvider.ts
+  var OpenRouterChatServiceProvider = class {
+    /**
+     * Create a chat service instance
+     * @param options Service options
+     * @returns OpenRouterChatService 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 tools = options.tools;
+      const appName = options.appName;
+      const appUrl = options.appUrl;
+      return new OpenRouterChatService(
+        options.apiKey,
+        options.model || this.getDefaultModel(),
+        visionModel,
+        tools,
+        options.endpoint,
+        options.responseLength,
+        appName,
+        appUrl,
+        options.reasoning_effort,
+        options.includeReasoning,
+        options.reasoningMaxTokens
+      );
+    }
+    /**
+     * Get the provider name
+     * @returns Provider name ('openrouter')
+     */
+    getProviderName() {
+      return "openrouter";
+    }
+    /**
+     * Get the list of supported models
+     * Currently only supports gpt-oss-20b:free
+     * @returns Array of supported model names
+     */
+    getSupportedModels() {
+      return [
+        // Free models
+        MODEL_GPT_OSS_20B_FREE
+      ];
+    }
+    /**
+     * Get the default model
+     * @returns Default model name (gpt-oss-20b:free)
+     */
+    getDefaultModel() {
+      return MODEL_GPT_OSS_20B_FREE;
+    }
+    /**
+     * Check if this provider supports vision (image processing)
+     * @returns Vision support status (false - gpt-oss-20b does not support vision)
+     */
+    supportsVision() {
+      return false;
+    }
+    /**
+     * 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 isOpenRouterVisionModel(model);
+    }
+    /**
+     * 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
+     */
+    isModelFree(model) {
+      return OPENROUTER_FREE_MODELS.includes(model) || model.endsWith(":free");
+    }
+  };
+
+  // src/services/ChatServiceFactory.ts
+  var ChatServiceFactory = class {
+    /**
+     * Register a new provider
+     * @param provider Provider instance
+     */
+    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) {
+        throw new Error(`Unknown chat provider: ${providerName}`);
+      }
+      return provider.createChatService(options);
+    }
+    /**
+     * Get registered providers
+     * @returns Provider map
+     */
+    static getProviders() {
+      return this.providers;
+    }
+    /**
+     * Get array of available provider names
+     * @returns Array of provider names
+     */
+    static getAvailableProviders() {
+      return Array.from(this.providers.keys());
+    }
+    /**
+     * Get models supported by the specified provider
+     * @param providerName Provider name
+     * @returns Array of supported models, empty array if provider doesn't exist
+     */
+    static getSupportedModels(providerName) {
+      const provider = this.providers.get(providerName);
+      return provider ? provider.getSupportedModels() : [];
+    }
+  };
+  /** 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());
+
+  // 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/adapters/gasFetch.ts
+  function installGASFetch() {
+    ChatServiceHttpClient.setFetch(async (url, init = {}) => {
+      const method = (init.method || "GET").toString().toUpperCase();
+      const rawHeaders = init.headers;
+      const headers = {};
+      if (Array.isArray(rawHeaders)) {
+        for (const [k, v] of rawHeaders) headers[k] = String(v);
+      } else if (rawHeaders && typeof rawHeaders === "object") {
+        for (const [k, v] of Object.entries(rawHeaders)) headers[k] = String(v);
+      }
+      const params = {
+        method,
+        headers,
+        muteHttpExceptions: true
+      };
+      const body = init.body;
+      if (typeof body === "string") {
+        params.payload = body;
+      } else if (body != null) {
+        if (!headers["Content-Type"])
+          headers["Content-Type"] = "application/json";
+        params.payload = JSON.stringify(body);
+      }
+      const res = UrlFetchApp.fetch(url, params);
+      const status = res.getResponseCode();
+      const text = res.getContentText();
+      const response = {
+        ok: status >= 200 && status < 300,
+        status,
+        statusText: String(status),
+        text: async () => text,
+        json: async () => text ? JSON.parse(text) : null
+      };
+      return response;
+    });
+  }
+  return __toCommonJS(index_exports);
+})();