@aituber-onair/chat 0.22.0 → 0.24.0

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

@@ -38,13 +38,17 @@ var AITuberOnAirChat = (() => {
     ENDPOINT_OPENAI_CHAT_COMPLETIONS_API: () => ENDPOINT_OPENAI_CHAT_COMPLETIONS_API,
     ENDPOINT_OPENAI_RESPONSES_API: () => ENDPOINT_OPENAI_RESPONSES_API,
     ENDPOINT_OPENROUTER_API: () => ENDPOINT_OPENROUTER_API,
+    ENDPOINT_XAI_CHAT_COMPLETIONS_API: () => ENDPOINT_XAI_CHAT_COMPLETIONS_API,
     ENDPOINT_ZAI_CHAT_COMPLETIONS_API: () => ENDPOINT_ZAI_CHAT_COMPLETIONS_API,
     EmotionParser: () => EmotionParser,
+    GEMINI_NANO_MAX_CONTEXT_MESSAGES: () => GEMINI_NANO_MAX_CONTEXT_MESSAGES,
     GEMINI_VISION_SUPPORTED_MODELS: () => GEMINI_VISION_SUPPORTED_MODELS,
     GPT5_PRESETS: () => GPT5_PRESETS,
     GPT_5_MODELS: () => GPT_5_MODELS,
     GeminiChatService: () => GeminiChatService,
     GeminiChatServiceProvider: () => GeminiChatServiceProvider,
+    GeminiNanoChatService: () => GeminiNanoChatService,
+    GeminiNanoChatServiceProvider: () => GeminiNanoChatServiceProvider,
     HttpError: () => HttpError,
     KIMI_VISION_SUPPORTED_MODELS: () => KIMI_VISION_SUPPORTED_MODELS,
     KimiChatService: () => KimiChatService,
@@ -76,6 +80,7 @@ var AITuberOnAirChat = (() => {
     MODEL_GEMINI_3_1_PRO_PREVIEW: () => MODEL_GEMINI_3_1_PRO_PREVIEW,
     MODEL_GEMINI_3_FLASH_PREVIEW: () => MODEL_GEMINI_3_FLASH_PREVIEW,
     MODEL_GEMINI_3_PRO_PREVIEW: () => MODEL_GEMINI_3_PRO_PREVIEW,
+    MODEL_GEMINI_NANO: () => MODEL_GEMINI_NANO,
     MODEL_GLM_4_6: () => MODEL_GLM_4_6,
     MODEL_GLM_4_6V: () => MODEL_GLM_4_6V,
     MODEL_GLM_4_6V_FLASH: () => MODEL_GLM_4_6V_FLASH,
@@ -102,6 +107,10 @@ var AITuberOnAirChat = (() => {
     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_GROK_4_1_FAST_NON_REASONING: () => MODEL_GROK_4_1_FAST_NON_REASONING,
+    MODEL_GROK_4_1_FAST_REASONING: () => MODEL_GROK_4_1_FAST_REASONING,
+    MODEL_GROK_4_20_NON_REASONING: () => MODEL_GROK_4_20_NON_REASONING,
+    MODEL_GROK_4_20_REASONING: () => MODEL_GROK_4_20_REASONING,
     MODEL_KIMI_K2_5: () => MODEL_KIMI_K2_5,
     MODEL_MOONSHOTAI_KIMI_K2_5: () => MODEL_MOONSHOTAI_KIMI_K2_5,
     MODEL_O1: () => MODEL_O1,
@@ -130,6 +139,9 @@ var AITuberOnAirChat = (() => {
     OpenRouterChatServiceProvider: () => OpenRouterChatServiceProvider,
     StreamTextAccumulator: () => StreamTextAccumulator,
     VISION_SUPPORTED_MODELS: () => VISION_SUPPORTED_MODELS,
+    XAIChatService: () => XAIChatService,
+    XAIChatServiceProvider: () => XAIChatServiceProvider,
+    XAI_VISION_SUPPORTED_MODELS: () => XAI_VISION_SUPPORTED_MODELS,
     ZAIChatService: () => ZAIChatService,
     ZAIChatServiceProvider: () => ZAIChatServiceProvider,
     ZAI_VISION_SUPPORTED_MODELS: () => ZAI_VISION_SUPPORTED_MODELS,
@@ -146,6 +158,7 @@ var AITuberOnAirChat = (() => {
     isOpenRouterFreeModel: () => isOpenRouterFreeModel,
     isOpenRouterVisionModel: () => isOpenRouterVisionModel,
     isResponsesOnlyGPT5Model: () => isResponsesOnlyGPT5Model,
+    isXaiVisionModel: () => isXaiVisionModel,
     isZaiToolStreamModel: () => isZaiToolStreamModel,
     isZaiVisionModel: () => isZaiVisionModel,
     parseOpenAICompatibleOneShot: () => parseOpenAICompatibleOneShot,
@@ -362,6 +375,22 @@ var AITuberOnAirChat = (() => {
     return model.toLowerCase().startsWith("glm-4.6");
   }
 
+  // src/constants/xai.ts
+  var ENDPOINT_XAI_CHAT_COMPLETIONS_API = "https://api.x.ai/v1/chat/completions";
+  var MODEL_GROK_4_20_REASONING = "grok-4.20-0309-reasoning";
+  var MODEL_GROK_4_20_NON_REASONING = "grok-4.20-0309-non-reasoning";
+  var MODEL_GROK_4_1_FAST_REASONING = "grok-4-1-fast-reasoning";
+  var MODEL_GROK_4_1_FAST_NON_REASONING = "grok-4-1-fast-non-reasoning";
+  var XAI_VISION_SUPPORTED_MODELS = [
+    MODEL_GROK_4_20_REASONING,
+    MODEL_GROK_4_20_NON_REASONING,
+    MODEL_GROK_4_1_FAST_REASONING,
+    MODEL_GROK_4_1_FAST_NON_REASONING
+  ];
+  function isXaiVisionModel(model) {
+    return XAI_VISION_SUPPORTED_MODELS.includes(model);
+  }
+
   // src/constants/kimi.ts
   var ENDPOINT_KIMI_CHAT_COMPLETIONS_API = "https://api.moonshot.ai/v1/chat/completions";
   var MODEL_KIMI_K2_5 = "kimi-k2.5";
@@ -427,6 +456,10 @@ If it's in English, summarize in English.
 If it's in another language, summarize in that language.
 `;
 
+  // src/constants/geminiNano.ts
+  var MODEL_GEMINI_NANO = "gemini-nano";
+  var GEMINI_NANO_MAX_CONTEXT_MESSAGES = 20;
+
   // src/utils/chatServiceHttpClient.ts
   var HttpError = class extends Error {
     constructor(status, statusText, body) {
@@ -2347,6 +2380,139 @@ If it's in another language, summarize in that language.
     }
   };
 
+  // src/services/providers/geminiNano/GeminiNanoChatService.ts
+  function getLanguageModelAPI() {
+    if (typeof globalThis !== "undefined" && "LanguageModel" in globalThis) {
+      return globalThis.LanguageModel;
+    }
+    return void 0;
+  }
+  var GeminiNanoChatService = class {
+    constructor(options = {}) {
+      this.provider = "gemini-nano";
+      this.expectedInputLanguages = options.expectedInputLanguages ?? ["ja"];
+      this.expectedOutputLanguages = options.expectedOutputLanguages ?? ["ja"];
+      this._responseLength = options.responseLength;
+      void this._responseLength;
+    }
+    getModel() {
+      return MODEL_GEMINI_NANO;
+    }
+    getVisionModel() {
+      return MODEL_GEMINI_NANO;
+    }
+    /**
+     * Process chat messages using Gemini Nano.
+     * Non-streaming: calls onPartialResponse once with the full response,
+     * then calls onCompleteResponse.
+     */
+    async processChat(messages, onPartialResponse, onCompleteResponse) {
+      const response = await this.generateResponse(messages);
+      onPartialResponse(response);
+      await onCompleteResponse(response);
+    }
+    async processVisionChat(_messages, _onPartialResponse, _onCompleteResponse) {
+      throw new Error("Gemini Nano does not support vision capabilities.");
+    }
+    async chatOnce(messages, _stream = false, onPartialResponse = () => {
+    }, _maxTokens) {
+      const response = await this.generateResponse(messages);
+      onPartialResponse(response);
+      return {
+        blocks: [{ type: "text", text: response }],
+        stop_reason: "end"
+      };
+    }
+    async visionChatOnce(_messages, _stream = false, _onPartialResponse = () => {
+    }, _maxTokens) {
+      throw new Error("Gemini Nano does not support vision capabilities.");
+    }
+    /**
+     * Core logic: extract system prompt, manage session, call prompt().
+     */
+    async generateResponse(messages) {
+      const api = getLanguageModelAPI();
+      if (!api) {
+        throw new Error(
+          "Gemini Nano is not available in this environment. Chrome 138+ with Prompt API enabled is required."
+        );
+      }
+      const availability = await api.availability();
+      if (availability !== "available" && availability !== "downloadable") {
+        throw new Error(
+          `Gemini Nano Prompt API is not ready in this environment. LanguageModel.availability() returned "${availability}". Expected "available" or "downloadable".`
+        );
+      }
+      const systemMessages = messages.filter((m) => m.role === "system");
+      const systemPrompt = systemMessages.map((m) => m.content).join("\n");
+      const conversationMessages = messages.filter((m) => m.role !== "system").slice(-GEMINI_NANO_MAX_CONTEXT_MESSAGES);
+      const lastUserMessage = [...conversationMessages].reverse().find((m) => m.role === "user");
+      if (!lastUserMessage) {
+        throw new Error("No user message found in the provided messages.");
+      }
+      const session = await this.createSession(
+        api,
+        systemPrompt,
+        conversationMessages
+      );
+      try {
+        return await session.prompt(lastUserMessage.content);
+      } finally {
+        try {
+          session.destroy();
+        } catch {
+        }
+      }
+    }
+    /**
+     * Create a new LanguageModel session with system prompt and context history.
+     * Context history (excluding the last user message) is embedded in the system prompt.
+     */
+    async createSession(api, systemPrompt, contextHistory) {
+      let prompt = systemPrompt;
+      const historyMessages = contextHistory.slice(0, -1);
+      if (historyMessages.length > 0) {
+        const history = historyMessages.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n");
+        prompt += "\n\n\u4EE5\u4E0B\u306F\u3053\u308C\u307E\u3067\u306E\u4F1A\u8A71\u5C65\u6B74\u3067\u3059\u3002\u3053\u306E\u6587\u8108\u3092\u8E0F\u307E\u3048\u3066\u56DE\u7B54\u3057\u3066\u304F\u3060\u3055\u3044:\n" + history;
+      }
+      return api.create({
+        systemPrompt: prompt,
+        expectedInputs: [
+          { type: "text", languages: this.expectedInputLanguages }
+        ],
+        expectedOutputs: [
+          { type: "text", languages: this.expectedOutputLanguages }
+        ]
+      });
+    }
+  };
+
+  // src/services/providers/geminiNano/GeminiNanoChatServiceProvider.ts
+  var GeminiNanoChatServiceProvider = class {
+    createChatService(options) {
+      return new GeminiNanoChatService({
+        expectedInputLanguages: options.expectedInputLanguages,
+        expectedOutputLanguages: options.expectedOutputLanguages,
+        responseLength: options.responseLength
+      });
+    }
+    getProviderName() {
+      return "gemini-nano";
+    }
+    getSupportedModels() {
+      return [MODEL_GEMINI_NANO];
+    }
+    getDefaultModel() {
+      return MODEL_GEMINI_NANO;
+    }
+    supportsVision() {
+      return false;
+    }
+    getVisionSupportLevel() {
+      return "unsupported";
+    }
+  };
+
   // src/services/providers/kimi/KimiChatService.ts
   var KimiChatService = class {
     /**
@@ -3734,6 +3900,225 @@ If it's in another language, summarize in that language.
     }
   };
 
+  // src/services/providers/xai/XAIChatService.ts
+  var XAIChatService = class {
+    /**
+     * Constructor
+     * @param apiKey xAI API key
+     * @param model Name of the model to use
+     * @param visionModel Name of the vision model
+     */
+    constructor(apiKey, model = MODEL_GROK_4_1_FAST_NON_REASONING, visionModel = MODEL_GROK_4_1_FAST_NON_REASONING, tools, endpoint = ENDPOINT_XAI_CHAT_COMPLETIONS_API, responseLength) {
+      /** Provider name */
+      this.provider = "xai";
+      this.apiKey = apiKey;
+      this.model = model;
+      this.tools = tools || [];
+      this.endpoint = endpoint;
+      this.responseLength = responseLength;
+      this.visionModel = visionModel;
+    }
+    /**
+     * Get the current model name
+     */
+    getModel() {
+      return this.model;
+    }
+    /**
+     * Get the current vision model name
+     */
+    getVisionModel() {
+      return this.visionModel;
+    }
+    /**
+     * Process chat messages
+     */
+    async processChat(messages, onPartialResponse, onCompleteResponse) {
+      await processChatWithOptionalTools({
+        hasTools: this.tools.length > 0,
+        runWithoutTools: async () => {
+          const res = await this.callXAI(messages, this.model, true);
+          return this.handleStream(res, onPartialResponse);
+        },
+        runWithTools: () => this.chatOnce(messages, true, onPartialResponse),
+        onCompleteResponse,
+        toolErrorMessage: "processChat received tool_calls. ChatProcessor must use chatOnce() loop when tools are enabled."
+      });
+    }
+    /**
+     * Process chat messages with images
+     */
+    async processVisionChat(messages, onPartialResponse, onCompleteResponse) {
+      if (!isXaiVisionModel(this.visionModel)) {
+        throw new Error(
+          `Model ${this.visionModel} does not support vision capabilities.`
+        );
+      }
+      await processChatWithOptionalTools({
+        hasTools: this.tools.length > 0,
+        runWithoutTools: async () => {
+          const res = await this.callXAI(messages, this.visionModel, true);
+          return this.handleStream(res, onPartialResponse);
+        },
+        runWithTools: () => this.visionChatOnce(messages, true, onPartialResponse),
+        onCompleteResponse,
+        toolErrorMessage: "processVisionChat received tool_calls. ChatProcessor must use visionChatOnce() loop when tools are enabled."
+      });
+    }
+    /**
+     * Process chat messages with tools (text only)
+     */
+    async chatOnce(messages, stream = true, onPartialResponse = () => {
+    }, maxTokens) {
+      const res = await this.callXAI(messages, this.model, stream, maxTokens);
+      return this.parseResponse(res, stream, onPartialResponse);
+    }
+    /**
+     * Process vision chat messages with tools
+     */
+    async visionChatOnce(messages, stream = false, onPartialResponse = () => {
+    }, maxTokens) {
+      if (!isXaiVisionModel(this.visionModel)) {
+        throw new Error(
+          `Model ${this.visionModel} does not support vision capabilities.`
+        );
+      }
+      const res = await this.callXAI(
+        messages,
+        this.visionModel,
+        stream,
+        maxTokens
+      );
+      return this.parseResponse(res, stream, onPartialResponse);
+    }
+    async parseResponse(res, stream, onPartialResponse) {
+      return stream ? this.parseStream(res, onPartialResponse) : this.parseOneShot(await res.json());
+    }
+    async callXAI(messages, model, stream = false, maxTokens) {
+      const body = this.buildRequestBody(messages, model, stream, maxTokens);
+      const res = await ChatServiceHttpClient.post(this.endpoint, body, {
+        Authorization: `Bearer ${this.apiKey}`
+      });
+      return res;
+    }
+    /**
+     * Build request body (OpenAI-compatible Chat Completions)
+     */
+    buildRequestBody(messages, model, stream, maxTokens) {
+      const body = {
+        model,
+        stream,
+        messages
+      };
+      const tokenLimit = maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength);
+      if (tokenLimit !== void 0) {
+        body.max_tokens = tokenLimit;
+      }
+      const tools = this.buildToolsDefinition();
+      if (tools.length > 0) {
+        body.tools = tools;
+        body.tool_choice = "auto";
+      }
+      return body;
+    }
+    buildToolsDefinition() {
+      return buildOpenAICompatibleTools(this.tools, "chat-completions");
+    }
+    async handleStream(res, onPartial) {
+      return parseOpenAICompatibleTextStream(res, onPartial, {
+        onJsonError: (payload) => console.debug("Failed to parse SSE data:", payload)
+      });
+    }
+    /**
+     * Parse streaming response with tool support
+     */
+    async parseStream(res, onPartial) {
+      return parseOpenAICompatibleToolStream(res, onPartial, {
+        onJsonError: (payload) => console.debug("Failed to parse SSE data:", payload)
+      });
+    }
+    /**
+     * Parse non-streaming response
+     */
+    parseOneShot(data) {
+      return parseOpenAICompatibleOneShot(data);
+    }
+  };
+
+  // src/services/providers/xai/XAIChatServiceProvider.ts
+  var XAIChatServiceProvider = class {
+    /**
+     * Create a chat service instance
+     */
+    createChatService(options) {
+      const model = options.model || this.getDefaultModel();
+      const visionModel = resolveVisionModel({
+        model,
+        visionModel: options.visionModel,
+        defaultModel: this.getDefaultModel(),
+        defaultVisionModel: this.getDefaultVisionModel(),
+        supportsVisionForModel: (visionModel2) => this.supportsVisionForModel(visionModel2),
+        validate: "explicit"
+      });
+      const tools = options.tools;
+      return new XAIChatService(
+        options.apiKey,
+        model,
+        visionModel,
+        tools,
+        options.endpoint || ENDPOINT_XAI_CHAT_COMPLETIONS_API,
+        options.responseLength
+      );
+    }
+    /**
+     * Get the provider name
+     */
+    getProviderName() {
+      return "xai";
+    }
+    /**
+     * Get the list of supported models
+     */
+    getSupportedModels() {
+      return [
+        MODEL_GROK_4_20_REASONING,
+        MODEL_GROK_4_20_NON_REASONING,
+        MODEL_GROK_4_1_FAST_REASONING,
+        MODEL_GROK_4_1_FAST_NON_REASONING
+      ];
+    }
+    /**
+     * Get the default model
+     */
+    getDefaultModel() {
+      return MODEL_GROK_4_1_FAST_NON_REASONING;
+    }
+    /**
+     * Get the default vision model
+     */
+    getDefaultVisionModel() {
+      return MODEL_GROK_4_1_FAST_NON_REASONING;
+    }
+    /**
+     * Check if this provider supports vision
+     */
+    supportsVision() {
+      return this.getVisionSupportLevel() !== "unsupported";
+    }
+    getVisionSupportLevel() {
+      return "supported";
+    }
+    /**
+     * Check if a specific model supports vision capabilities
+     */
+    supportsVisionForModel(model) {
+      return isXaiVisionModel(model);
+    }
+    getVisionSupportLevelForModel(model) {
+      return this.supportsVisionForModel(model) ? "supported" : "unsupported";
+    }
+  };
+
   // src/services/providers/zai/ZAIChatService.ts
   var ZAIChatService = class {
     /**
@@ -3977,9 +4362,11 @@ If it's in another language, summarize in that language.
     new OpenAIChatServiceProvider(),
     new OpenAICompatibleChatServiceProvider(),
     new GeminiChatServiceProvider(),
+    new GeminiNanoChatServiceProvider(),
     new ClaudeChatServiceProvider(),
     new OpenRouterChatServiceProvider(),
     new ZAIChatServiceProvider(),
+    new XAIChatServiceProvider(),
     new KimiChatServiceProvider()
   ];