@aituber-onair/chat 0.37.0 → 0.39.0

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

@@ -163,6 +163,7 @@ var AITuberOnAirChat = (() => {
     MODEL_OPENAI_GPT_LATEST: () => MODEL_OPENAI_GPT_LATEST,
     MODEL_OPENAI_GPT_MINI_LATEST: () => MODEL_OPENAI_GPT_MINI_LATEST,
     MODEL_OPENROUTER_AUTO: () => MODEL_OPENROUTER_AUTO,
+    MODEL_OPENROUTER_FUSION: () => MODEL_OPENROUTER_FUSION,
     MODEL_ZAI_GLM_4_5_AIR: () => MODEL_ZAI_GLM_4_5_AIR,
     MODEL_ZAI_GLM_4_5_AIR_FREE: () => MODEL_ZAI_GLM_4_5_AIR_FREE,
     MODEL_ZAI_GLM_4_7_FLASH: () => MODEL_ZAI_GLM_4_7_FLASH,
@@ -213,6 +214,8 @@ var AITuberOnAirChat = (() => {
     refreshOpenRouterFreeModels: () => refreshOpenRouterFreeModels,
     resolveVisionModel: () => resolveVisionModel,
     runOnceText: () => runOnceText,
+    safeJsonParse: () => safeJsonParse,
+    safeParseToolCallInput: () => safeParseToolCallInput,
     screenplayToText: () => screenplayToText,
     textToScreenplay: () => textToScreenplay,
     textsToScreenplay: () => textsToScreenplay
@@ -286,7 +289,7 @@ var AITuberOnAirChat = (() => {
     return model !== MODEL_GPT_5_4_PRO;
   }
   function getDefaultReasoningEffortForGPT5Model(model) {
-    if (model === MODEL_GPT_5_1 || model === MODEL_GPT_5_4 || model === MODEL_GPT_5_5) {
+    if (allowsReasoningNone(model)) {
       return "none";
     }
     return "medium";
@@ -358,6 +361,7 @@ var AITuberOnAirChat = (() => {
   // src/constants/openrouter.ts
   var ENDPOINT_OPENROUTER_API = "https://openrouter.ai/api/v1/chat/completions";
   var MODEL_OPENROUTER_AUTO = "openrouter/auto";
+  var MODEL_OPENROUTER_FUSION = "openrouter/fusion";
   var MODEL_GPT_OSS_20B_FREE = "openai/gpt-oss-20b:free";
   var MODEL_MOONSHOTAI_KIMI_K2_5 = "moonshotai/kimi-k2.5";
   var MODEL_MOONSHOTAI_KIMI_LATEST = "~moonshotai/kimi-latest";
@@ -836,6 +840,22 @@ If it's in another language, summarize in that language.
     return StreamTextAccumulator.getFullText(blocks);
   }
 
+  // src/utils/safeJsonParse.ts
+  var safeJsonParse = (payload, fallback, onJsonError) => {
+    try {
+      return JSON.parse(payload);
+    } catch (error) {
+      onJsonError?.(payload, error);
+      return fallback;
+    }
+  };
+  var safeParseToolCallInput = (payload, onJsonError) => {
+    if (!payload) {
+      return {};
+    }
+    return safeJsonParse(payload, {}, onJsonError);
+  };
+
   // src/utils/openaiCompatibleSse.ts
   var parseJsonPayload = (payload, onJsonError) => {
     try {
@@ -943,7 +963,7 @@ If it's in another language, summarize in that language.
       type: "tool_use",
       id: e.id,
       name: e.name,
-      input: JSON.parse(e.args || "{}")
+      input: safeParseToolCallInput(e.args, options.onJsonError)
     }));
     const blocks = [...textBlocks, ...toolBlocks];
     return {
@@ -954,7 +974,7 @@ If it's in another language, summarize in that language.
       usage
     };
   }
-  function parseOpenAICompatibleOneShot(data) {
+  function parseOpenAICompatibleOneShot(data, options = {}) {
     const choice = data?.choices?.[0];
     const blocks = [];
     if (choice?.message?.tool_calls?.length) {
@@ -963,7 +983,10 @@ If it's in another language, summarize in that language.
           type: "tool_use",
           id: c.id,
           name: c.function?.name,
-          input: JSON.parse(c.function?.arguments || "{}")
+          input: safeParseToolCallInput(
+            c.function?.arguments,
+            options.onJsonError
+          )
         })
       );
     } else {
@@ -1755,7 +1778,7 @@ If it's in another language, summarize in that language.
   };
 
   // src/services/providers/openai/responsesParser.ts
-  async function parseOpenAIResponsesStream(res, onPartial) {
+  async function parseOpenAIResponsesStream(res, onPartial, options = {}) {
     const reader = res.body.getReader();
     const dec = new TextDecoder();
     const textBlocks = [];
@@ -1787,6 +1810,7 @@ If it's in another language, summarize in that language.
               onPartial,
               textBlocks,
               toolCallsMap,
+              options,
               (metadata) => {
                 if (metadata.responseStatus !== void 0) {
                   responseStatus = metadata.responseStatus;
@@ -1799,7 +1823,8 @@ If it's in another language, summarize in that language.
                 }
               }
             );
-          } catch {
+          } catch (error) {
+            options.onJsonError?.(eventData, error);
             console.warn("Failed to parse SSE data:", eventData);
           }
           eventType = "";
@@ -1824,7 +1849,7 @@ If it's in another language, summarize in that language.
       usage
     };
   }
-  function handleResponsesSSEEvent(eventType, data, onPartial, textBlocks, toolCallsMap, onMetadata) {
+  function handleResponsesSSEEvent(eventType, data, onPartial, textBlocks, toolCallsMap, options, onMetadata) {
     switch (eventType) {
       case "response.output_item.added":
         if (data.item?.type === "message" && Array.isArray(data.item.content)) {
@@ -1838,7 +1863,10 @@ If it's in another language, summarize in that language.
           toolCallsMap.set(data.item.id, {
             id: data.item.id,
             name: data.item.name,
-            input: data.item.arguments ? JSON.parse(data.item.arguments) : {}
+            input: safeParseToolCallInput(
+              data.item.arguments,
+              options.onJsonError
+            )
           });
         }
         break;
@@ -1881,7 +1909,7 @@ If it's in another language, summarize in that language.
       usage: response?.usage
     };
   }
-  function parseOpenAIResponsesOneShot(data) {
+  function parseOpenAIResponsesOneShot(data, options = {}) {
     const blocks = [];
     if (data.output && Array.isArray(data.output)) {
       data.output.forEach((outputItem) => {
@@ -1897,7 +1925,10 @@ If it's in another language, summarize in that language.
             type: "tool_use",
             id: outputItem.id,
             name: outputItem.name,
-            input: outputItem.arguments ? JSON.parse(outputItem.arguments) : {}
+            input: safeParseToolCallInput(
+              outputItem.arguments,
+              options.onJsonError
+            )
           });
         }
       });
@@ -2414,6 +2445,20 @@ If it's in another language, summarize in that language.
   };
 
   // src/utils/mcpSchemaFetcher.ts
+  var createGenericSearchTool = (serverConfig, reason) => ({
+    name: `mcp_${serverConfig.name}_search`,
+    description: reason === "schema-fetch-failed" ? `Search using ${serverConfig.name} MCP server (schema fetch failed)` : `Search using ${serverConfig.name} MCP server`,
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query"
+        }
+      },
+      required: ["query"]
+    }
+  });
   var MCPSchemaFetcher = class {
     /**
      * Fetch tool schemas from MCP server
@@ -2421,6 +2466,15 @@ If it's in another language, summarize in that language.
      * @returns Array of tool definitions
      */
     static async fetchToolSchemas(serverConfig) {
+      const result = await this.fetchToolSchemasWithStatus(serverConfig);
+      return result.schemas;
+    }
+    /**
+     * Fetch tool schemas from MCP server with failure metadata.
+     * @param serverConfig MCP server configuration
+     * @returns Tool schemas and failure metadata if fallback was used
+     */
+    static async fetchToolSchemasWithStatus(serverConfig) {
       try {
         const headers = {
           "Content-Type": "application/json"
@@ -2435,53 +2489,32 @@ If it's in another language, summarize in that language.
         );
         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 {
+            schemas: 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: []
+              }
+            })),
+            failures: []
+          };
         }
-        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"]
-            }
-          }
-        ];
+        return {
+          schemas: [createGenericSearchTool(serverConfig)],
+          failures: []
+        };
       } catch (error) {
         console.warn(
           `Failed to fetch MCP schemas from ${serverConfig.name}:`,
           error
         );
-        return [
-          {
-            name: `mcp_${serverConfig.name}_search`,
-            description: `Search using ${serverConfig.name} MCP server (schema fetch failed)`,
-            parameters: {
-              type: "object",
-              properties: {
-                query: {
-                  type: "string",
-                  description: "Search query"
-                }
-              },
-              required: ["query"]
-            }
-          }
-        ];
+        return {
+          schemas: [createGenericSearchTool(serverConfig, "schema-fetch-failed")],
+          failures: [{ server: serverConfig, error }]
+        };
       }
     }
     /**
@@ -2490,16 +2523,28 @@ If it's in another language, summarize in that language.
      * @returns Array of all tool definitions
      */
     static async fetchAllToolSchemas(mcpServers) {
+      const result = await this.fetchAllToolSchemasWithStatus(mcpServers);
+      return result.schemas;
+    }
+    /**
+     * Fetch all tool schemas from multiple MCP servers with failure metadata.
+     * @param mcpServers Array of MCP server configurations
+     * @returns Array of all tool definitions and failures
+     */
+    static async fetchAllToolSchemasWithStatus(mcpServers) {
       const allSchemas = [];
+      const failures = [];
       for (const server of mcpServers) {
         try {
-          const schemas = await this.fetchToolSchemas(server);
-          allSchemas.push(...schemas);
+          const result = await this.fetchToolSchemasWithStatus(server);
+          allSchemas.push(...result.schemas);
+          failures.push(...result.failures);
         } catch (error) {
           console.error(`Failed to fetch schemas from ${server.name}:`, error);
+          failures.push({ server, error });
         }
       }
-      return allSchemas;
+      return { schemas: allSchemas, failures };
     }
   };
 
@@ -2555,7 +2600,7 @@ If it's in another language, summarize in that language.
             {
               functionResponse: {
                 name: funcName,
-                response: normalizeToolResult(safeJsonParse(msg.content))
+                response: normalizeToolResult(safeJsonParse2(msg.content))
               }
             }
           ]
@@ -2602,7 +2647,7 @@ If it's in another language, summarize in that language.
               functionResponse: {
                 name: funcName,
                 response: normalizeToolResult(
-                  safeJsonParse(msg.content)
+                  safeJsonParse2(msg.content)
                 )
               }
             }
@@ -2651,7 +2696,7 @@ If it's in another language, summarize in that language.
     }
     return geminiMessages;
   }
-  function safeJsonParse(str) {
+  function safeJsonParse2(str) {
     try {
       return JSON.parse(str);
     } catch {
@@ -2810,6 +2855,7 @@ If it's in another language, summarize in that language.
     addMCPServer(serverConfig) {
       this.mcpServers.push(serverConfig);
       this.mcpSchemasInitialized = false;
+      this.mcpSchemaInitializationError = void 0;
     }
     /**
      * Remove MCP server by name
@@ -2820,6 +2866,7 @@ If it's in another language, summarize in that language.
         (server) => server.name !== serverName
       );
       this.mcpSchemasInitialized = false;
+      this.mcpSchemaInitializationError = void 0;
     }
     /**
      * Check if MCP servers are configured
@@ -2828,6 +2875,12 @@ If it's in another language, summarize in that language.
     hasMCPServers() {
       return this.mcpServers.length > 0;
     }
+    /**
+     * Get the last MCP schema initialization error, if schema fallback was used.
+     */
+    getMCPSchemaInitializationError() {
+      return this.mcpSchemaInitializationError;
+    }
     /**
      * Initialize MCP tool schemas by fetching from servers
      * @private
@@ -2840,16 +2893,16 @@ If it's in another language, summarize in that language.
         const timeoutPromise = new Promise(
           (_, reject) => setTimeout(() => reject(new Error("MCP schema fetch timeout")), 5e3)
         );
-        const schemasPromise = MCPSchemaFetcher.fetchAllToolSchemas(
+        const schemasPromise = MCPSchemaFetcher.fetchAllToolSchemasWithStatus(
           this.mcpServers
         );
-        this.mcpToolSchemas = await Promise.race([
-          schemasPromise,
-          timeoutPromise
-        ]);
+        const result = await Promise.race([schemasPromise, timeoutPromise]);
+        this.mcpToolSchemas = result.schemas;
         this.mcpSchemasInitialized = true;
+        this.mcpSchemaInitializationError = result.failures[0]?.error;
       } catch (error) {
         console.warn("Failed to initialize MCP schemas, using fallback:", error);
+        this.mcpSchemaInitializationError = error;
         this.mcpToolSchemas = createFallbackMCPToolSchemas(this.mcpServers);
         this.mcpSchemasInitialized = true;
       }
@@ -2970,7 +3023,14 @@ If it's in another language, summarize in that language.
         } catch (e) {
           const looksLikeVersionMismatch = /Unknown name|Cannot find field|404/.test(e?.message || "") || e?.status === 404;
           if (!requiresV1beta && looksLikeVersionMismatch) {
-            return await fetchOnce("v1beta", this.adaptKeysForApi(body));
+            try {
+              return await fetchOnce("v1beta", this.adaptKeysForApi(body));
+            } catch (fallbackError) {
+              if (fallbackError instanceof Error) {
+                fallbackError.cause = e;
+              }
+              throw fallbackError;
+            }
           }
           throw e;
         }
@@ -3895,28 +3955,38 @@ If it's in another language, summarize in that language.
     }
     /**
      * Normalize reasoning effort to a model-supported value
+     *
+     * Unsupported values are rounded to the nearest supported level instead of
+     * resetting to the model default, so a low-latency request stays low
+     * (e.g. 'minimal' on GPT-5.4 resolves to 'none', not 'medium') and a
+     * high-effort request stays high (e.g. 'xhigh' on GPT-5.1 resolves to
+     * 'high', not 'none').
      */
     normalizeReasoningEffort(modelName, effort) {
       if (!effort) {
         return void 0;
       }
-      if (effort === "none" && !allowsReasoningNone(modelName)) {
-        return getDefaultReasoningEffortForGPT5Model(modelName);
-      }
-      if (effort === "minimal" && !allowsReasoningMinimal(modelName)) {
-        return getDefaultReasoningEffortForGPT5Model(modelName);
+      if (effort === "none" && !allowsReasoningNone(modelName) || effort === "minimal" && !allowsReasoningMinimal(modelName)) {
+        if (effort === "minimal" && allowsReasoningNone(modelName)) {
+          return "none";
+        }
+        if (effort === "none" && allowsReasoningMinimal(modelName)) {
+          return "minimal";
+        }
+        return allowsReasoningLow(modelName) ? "low" : "medium";
       }
       if (effort === "low" && !allowsReasoningLow(modelName)) {
-        return getDefaultReasoningEffortForGPT5Model(modelName);
+        return "medium";
       }
       if (effort === "xhigh" && !allowsReasoningXHigh(modelName)) {
-        return getDefaultReasoningEffortForGPT5Model(modelName);
+        return "high";
       }
       return effort;
     }
   };
 
   // src/services/providers/openrouter/OpenRouterChatService.ts
+  var isTokenLimitUnsupportedModel = (model) => model.trim() === MODEL_GPT_OSS_20B_FREE;
   var OpenRouterChatService = class {
     /**
      * Constructor
@@ -4110,10 +4180,12 @@ If it's in another language, summarize in that language.
         stream
       };
       const tokenLimit = maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength);
-      if (tokenLimit) {
+      if (tokenLimit && isTokenLimitUnsupportedModel(model)) {
         console.warn(
-          `OpenRouter: Token limits are not supported for gpt-oss-20b model due to known issues. Using unlimited tokens instead.`
+          `OpenRouter: Token limits are not supported for ${model} due to known issues. Using unlimited tokens instead.`
         );
+      } else if (tokenLimit) {
+        body.max_tokens = tokenLimit;
       }
       if (this.reasoning_effort !== void 0 || this.includeReasoning !== void 0 || this.reasoningMaxTokens) {
         body.reasoning = {};
@@ -4210,6 +4282,7 @@ If it's in another language, summarize in that language.
       return [
         // OpenRouter routing
         MODEL_OPENROUTER_AUTO,
+        MODEL_OPENROUTER_FUSION,
         // Free models
         MODEL_GPT_OSS_20B_FREE,
         MODEL_ZAI_GLM_4_5_AIR_FREE,