@aituber-onair/chat 0.47.0 → 0.48.0

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

@@ -106,6 +106,8 @@ var AITuberOnAirChat = (() => {
     MODEL_GEMINI_3_1_FLASH_LITE_PREVIEW: () => MODEL_GEMINI_3_1_FLASH_LITE_PREVIEW,
     MODEL_GEMINI_3_1_PRO_PREVIEW: () => MODEL_GEMINI_3_1_PRO_PREVIEW,
     MODEL_GEMINI_3_5_FLASH: () => MODEL_GEMINI_3_5_FLASH,
+    MODEL_GEMINI_3_5_FLASH_LITE: () => MODEL_GEMINI_3_5_FLASH_LITE,
+    MODEL_GEMINI_3_6_FLASH: () => MODEL_GEMINI_3_6_FLASH,
     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,
@@ -157,6 +159,7 @@ var AITuberOnAirChat = (() => {
     MODEL_KIMI_K2_6: () => MODEL_KIMI_K2_6,
     MODEL_KIMI_K2_7_CODE: () => MODEL_KIMI_K2_7_CODE,
     MODEL_KIMI_K2_7_CODE_HIGHSPEED: () => MODEL_KIMI_K2_7_CODE_HIGHSPEED,
+    MODEL_KIMI_K3: () => MODEL_KIMI_K3,
     MODEL_MINISTRAL_14B_2512: () => MODEL_MINISTRAL_14B_2512,
     MODEL_MINISTRAL_3B_2512: () => MODEL_MINISTRAL_3B_2512,
     MODEL_MINISTRAL_8B_2512: () => MODEL_MINISTRAL_8B_2512,
@@ -226,11 +229,16 @@ var AITuberOnAirChat = (() => {
     allowsReasoningNone: () => allowsReasoningNone,
     allowsReasoningXHigh: () => allowsReasoningXHigh,
     buildOpenAICompatibleTools: () => buildOpenAICompatibleTools,
+    getDefaultGeminiReasoningEffort: () => getDefaultGeminiReasoningEffort,
     getDefaultReasoningEffortForGPT5Model: () => getDefaultReasoningEffortForGPT5Model,
     getDefaultXaiReasoningEffort: () => getDefaultXaiReasoningEffort,
+    getGeminiSupportedReasoningEfforts: () => getGeminiSupportedReasoningEfforts,
+    getKimiSupportedReasoningEfforts: () => getKimiSupportedReasoningEfforts,
     getMaxTokensForResponseLength: () => getMaxTokensForResponseLength,
     installGASFetch: () => installGASFetch,
     isGPT5Model: () => isGPT5Model,
+    isGeminiReasoningEffortModel: () => isGeminiReasoningEffortModel,
+    isKimiReasoningEffortModel: () => isKimiReasoningEffortModel,
     isKimiThinkingRequiredModel: () => isKimiThinkingRequiredModel,
     isKimiVisionModel: () => isKimiVisionModel,
     isMistralReasoningEffort: () => isMistralReasoningEffort,
@@ -244,6 +252,7 @@ var AITuberOnAirChat = (() => {
     isXaiVisionModel: () => isXaiVisionModel,
     isZaiToolStreamModel: () => isZaiToolStreamModel,
     isZaiVisionModel: () => isZaiVisionModel,
+    normalizeGeminiReasoningEffort: () => normalizeGeminiReasoningEffort,
     normalizeXaiReasoningEffort: () => normalizeXaiReasoningEffort,
     parseOpenAICompatibleOneShot: () => parseOpenAICompatibleOneShot,
     parseOpenAICompatibleTextStream: () => parseOpenAICompatibleTextStream,
@@ -355,7 +364,9 @@ var AITuberOnAirChat = (() => {
   var ENDPOINT_GEMINI_API = "https://generativelanguage.googleapis.com";
   var MODEL_GEMMA_4_31B_IT = "gemma-4-31b-it";
   var MODEL_GEMMA_4_26B_A4B_IT = "gemma-4-26b-a4b-it";
+  var MODEL_GEMINI_3_6_FLASH = "gemini-3.6-flash";
   var MODEL_GEMINI_3_5_FLASH = "gemini-3.5-flash";
+  var MODEL_GEMINI_3_5_FLASH_LITE = "gemini-3.5-flash-lite";
   var MODEL_GEMINI_3_1_PRO_PREVIEW = "gemini-3.1-pro-preview";
   var MODEL_GEMINI_3_1_FLASH_LITE = "gemini-3.1-flash-lite";
   var MODEL_GEMINI_3_1_FLASH_LITE_PREVIEW = "gemini-3.1-flash-lite-preview";
@@ -366,7 +377,9 @@ var AITuberOnAirChat = (() => {
   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 GEMINI_RECOMMENDED_MODELS = [
+    MODEL_GEMINI_3_6_FLASH,
     MODEL_GEMINI_3_5_FLASH,
+    MODEL_GEMINI_3_5_FLASH_LITE,
     MODEL_GEMINI_3_1_FLASH_LITE,
     MODEL_GEMINI_3_1_PRO_PREVIEW,
     MODEL_GEMINI_3_FLASH_PREVIEW,
@@ -385,6 +398,54 @@ var AITuberOnAirChat = (() => {
     ...GEMINI_RECOMMENDED_MODELS,
     ...GEMINI_DEPRECATED_MODELS
   ];
+  var GEMINI_FLASH_REASONING_EFFORTS = [
+    "minimal",
+    "low",
+    "medium",
+    "high"
+  ];
+  var GEMINI_PRO_REASONING_EFFORTS = [
+    "low",
+    "medium",
+    "high"
+  ];
+  var GEMINI_FLASH_REASONING_EFFORT_MODELS = [
+    MODEL_GEMINI_3_6_FLASH,
+    MODEL_GEMINI_3_5_FLASH,
+    MODEL_GEMINI_3_5_FLASH_LITE,
+    MODEL_GEMINI_3_1_FLASH_LITE,
+    MODEL_GEMINI_3_1_FLASH_LITE_PREVIEW,
+    MODEL_GEMINI_3_FLASH_PREVIEW
+  ];
+  var GEMINI_PRO_REASONING_EFFORT_MODELS = [
+    MODEL_GEMINI_3_1_PRO_PREVIEW,
+    MODEL_GEMINI_3_PRO_PREVIEW
+  ];
+  function getGeminiSupportedReasoningEfforts(model) {
+    if (GEMINI_FLASH_REASONING_EFFORT_MODELS.includes(model)) {
+      return GEMINI_FLASH_REASONING_EFFORTS;
+    }
+    if (GEMINI_PRO_REASONING_EFFORT_MODELS.includes(model)) {
+      return GEMINI_PRO_REASONING_EFFORTS;
+    }
+    return [];
+  }
+  function isGeminiReasoningEffortModel(model) {
+    return getGeminiSupportedReasoningEfforts(model).length > 0;
+  }
+  function getDefaultGeminiReasoningEffort(model) {
+    return getGeminiSupportedReasoningEfforts(model)[0];
+  }
+  function normalizeGeminiReasoningEffort(model, effort) {
+    const supported = getGeminiSupportedReasoningEfforts(model);
+    if (supported.length === 0) {
+      return void 0;
+    }
+    if (effort && supported.includes(effort)) {
+      return effort;
+    }
+    return supported[0];
+  }
 
   // src/constants/claude.ts
   var ENDPOINT_CLAUDE_API = "https://api.anthropic.com/v1/messages";
@@ -565,11 +626,16 @@ var AITuberOnAirChat = (() => {
 
   // src/constants/kimi.ts
   var ENDPOINT_KIMI_CHAT_COMPLETIONS_API = "https://api.moonshot.ai/v1/chat/completions";
+  var MODEL_KIMI_K3 = "kimi-k3";
   var MODEL_KIMI_K2_7_CODE = "kimi-k2.7-code";
   var MODEL_KIMI_K2_7_CODE_HIGHSPEED = "kimi-k2.7-code-highspeed";
   var MODEL_KIMI_K2_6 = "kimi-k2.6";
   var MODEL_KIMI_K2_5 = "kimi-k2.5";
+  var KIMI_REASONING_EFFORTS_BY_MODEL = {
+    [MODEL_KIMI_K3]: ["max"]
+  };
   var KIMI_VISION_SUPPORTED_MODELS = [
+    MODEL_KIMI_K3,
     MODEL_KIMI_K2_7_CODE,
     MODEL_KIMI_K2_7_CODE_HIGHSPEED,
     MODEL_KIMI_K2_6,
@@ -585,6 +651,12 @@ var AITuberOnAirChat = (() => {
   function isKimiThinkingRequiredModel(model) {
     return KIMI_THINKING_REQUIRED_MODELS.includes(model);
   }
+  function getKimiSupportedReasoningEfforts(model) {
+    return KIMI_REASONING_EFFORTS_BY_MODEL[model] ?? [];
+  }
+  function isKimiReasoningEffortModel(model) {
+    return getKimiSupportedReasoningEfforts(model).length > 0;
+  }
 
   // src/constants/deepseek.ts
   var DEEPSEEK_API_BASE_URL = "https://api.deepseek.com";
@@ -1061,6 +1133,8 @@ If it's in another language, summarize in that language.
   async function parseOpenAICompatibleToolStream(res, onPartial, options = {}) {
     const textBlocks = [];
     const toolCallsMap = /* @__PURE__ */ new Map();
+    let fullContent = "";
+    let reasoningContent = "";
     let finishReason;
     let usage;
     const appendTextBlock = options.appendTextBlock ?? StreamTextAccumulator.append;
@@ -1079,14 +1153,23 @@ If it's in another language, summarize in that language.
       if (content) {
         onPartial(content);
         appendTextBlock(textBlocks, content);
+        fullContent += content;
+      }
+      const reasoning = extractTextContent(delta?.reasoning_content);
+      if (reasoning) {
+        reasoningContent += reasoning;
       }
       if (delta?.tool_calls) {
         delta.tool_calls.forEach((c) => {
           const entry = toolCallsMap.get(c.index) ?? {
             id: c.id,
+            type: c.type,
             name: c.function?.name,
             args: ""
           };
+          if (c.id) entry.id = c.id;
+          if (c.type) entry.type = c.type;
+          if (c.function?.name) entry.name = c.function.name;
           entry.args += c.function?.arguments || "";
           toolCallsMap.set(c.index, entry);
         });
@@ -1099,17 +1182,35 @@ If it's in another language, summarize in that language.
       input: safeParseToolCallInput(e.args, options.onJsonError)
     }));
     const blocks = [...textBlocks, ...toolBlocks];
+    const assistantToolCalls = Array.from(
+      toolCallsMap.entries()
+    ).sort((a, b) => a[0] - b[0]).map(([_, entry]) => ({
+      id: entry.id,
+      type: "function",
+      function: {
+        name: entry.name,
+        arguments: entry.args
+      }
+    }));
+    const assistantMessage = {
+      role: "assistant",
+      content: fullContent,
+      ...reasoningContent ? { reasoning_content: reasoningContent } : {},
+      ...assistantToolCalls.length > 0 ? { tool_calls: assistantToolCalls } : {}
+    };
     return {
       blocks,
       stop_reason: toolBlocks.length ? "tool_use" : "end",
       truncated: finishReason === "length",
       finish_reason: finishReason,
-      usage
+      usage,
+      ...options.preserveAssistantMessage ? { assistant_message: assistantMessage } : {}
     };
   }
   function parseOpenAICompatibleOneShot(data, options = {}) {
     const choice = data?.choices?.[0];
     const blocks = [];
+    const content = extractTextContent(choice?.message?.content);
     if (choice?.message?.tool_calls?.length) {
       choice.message.tool_calls.forEach(
         (c) => blocks.push({
@@ -1122,18 +1223,21 @@ If it's in another language, summarize in that language.
           )
         })
       );
-    } else {
-      const content = extractTextContent(choice?.message?.content);
-      if (content) {
-        blocks.push({ type: "text", text: content });
-      }
-    }
+    } else if (content) {
+      blocks.push({ type: "text", text: content });
+    }
+    const assistantMessage = choice?.message ? {
+      ...choice.message,
+      role: "assistant",
+      content
+    } : void 0;
     return {
       blocks,
       stop_reason: choice?.finish_reason === "tool_calls" || blocks.some((b) => b.type === "tool_use") ? "tool_use" : "end",
       truncated: choice?.finish_reason === "length",
       finish_reason: choice?.finish_reason,
-      usage: data?.usage
+      usage: data?.usage,
+      ...options.preserveAssistantMessage ? { assistant_message: assistantMessage } : {}
     };
   }
 
@@ -1161,8 +1265,15 @@ If it's in another language, summarize in that language.
   // src/utils/processChatFlow.ts
   async function processChatWithOptionalTools(options) {
     if (!options.hasTools) {
-      const full = await options.runWithoutTools();
-      await options.onCompleteResponse(full);
+      const result2 = await options.runWithoutTools();
+      if (typeof result2 === "string") {
+        await options.onCompleteResponse(result2);
+        return;
+      }
+      const full = StreamTextAccumulator.getFullText(
+        result2.blocks
+      );
+      await options.onCompleteResponse(full, result2);
       return;
     }
     const result = await options.runWithTools();
@@ -1173,7 +1284,7 @@ If it's in another language, summarize in that language.
       const full = StreamTextAccumulator.getFullText(
         result.blocks
       );
-      await options.onCompleteResponse(full);
+      await options.onCompleteResponse(full, result);
       return;
     }
     throw new Error(options.toolErrorMessage);
@@ -2732,41 +2843,26 @@ If it's in another language, summarize in that language.
         gemini.push({ role: currentRole, parts: [...currentParts] });
         currentParts = [];
       }
+      currentRole = null;
     };
     for (const msg of messages) {
       const role = mapRoleToGemini(msg.role);
       if (msg.tool_calls) {
         pushCurrent();
-        for (const call of msg.tool_calls) {
-          options.callIdMap?.set(call.id, call.function.name);
+        const parts = msg.tool_calls.map(
+          (call) => createFunctionCallPart(call, options)
+        );
+        if (parts.length > 0) {
           gemini.push({
             role: "model",
-            parts: [
-              {
-                functionCall: {
-                  name: call.function.name,
-                  args: JSON.parse(call.function.arguments || "{}")
-                }
-              }
-            ]
+            parts
           });
         }
         continue;
       }
       if (msg.role === "tool") {
         pushCurrent();
-        const funcName = msg.name ?? options.callIdMap?.get(msg.tool_call_id) ?? "result";
-        gemini.push({
-          role: "user",
-          parts: [
-            {
-              functionResponse: {
-                name: funcName,
-                response: normalizeToolResult(safeJsonParse2(msg.content))
-              }
-            }
-          ]
-        });
+        appendFunctionResponse(gemini, createFunctionResponsePart(msg, options));
         continue;
       }
       if (role !== currentRole) pushCurrent();
@@ -2782,47 +2878,41 @@ If it's in another language, summarize in that language.
     const geminiMessages = [];
     let currentRole = null;
     let currentParts = [];
+    const pushCurrent = () => {
+      if (currentRole && currentParts.length > 0) {
+        geminiMessages.push({
+          role: currentRole,
+          parts: [...currentParts]
+        });
+        currentParts = [];
+      }
+      currentRole = null;
+    };
     for (const msg of messages) {
       const role = mapRoleToGemini(msg.role);
       if (msg.tool_calls) {
-        for (const call of msg.tool_calls) {
+        pushCurrent();
+        const parts = msg.tool_calls.map(
+          (call) => createFunctionCallPart(call, options)
+        );
+        if (parts.length > 0) {
           geminiMessages.push({
             role: "model",
-            parts: [
-              {
-                functionCall: {
-                  name: call.function.name,
-                  args: JSON.parse(call.function.arguments || "{}")
-                }
-              }
-            ]
+            parts
           });
         }
         continue;
       }
       if (msg.role === "tool") {
-        const funcName = msg.name ?? options.callIdMap?.get(msg.tool_call_id) ?? "result";
-        geminiMessages.push({
-          role: "user",
-          parts: [
-            {
-              functionResponse: {
-                name: funcName,
-                response: normalizeToolResult(
-                  safeJsonParse2(msg.content)
-                )
-              }
-            }
-          ]
-        });
+        pushCurrent();
+        appendFunctionResponse(
+          geminiMessages,
+          createFunctionResponsePart(msg, options)
+        );
         continue;
       }
       if (role !== currentRole && currentParts.length > 0) {
-        geminiMessages.push({
-          role: currentRole,
-          parts: [...currentParts]
-        });
-        currentParts = [];
+        pushCurrent();
       }
       currentRole = role;
       if (typeof msg.content === "string") {
@@ -2850,14 +2940,43 @@ If it's in another language, summarize in that language.
         }
       }
     }
-    if (currentRole && currentParts.length > 0) {
-      geminiMessages.push({
-        role: currentRole,
-        parts: [...currentParts]
-      });
-    }
+    pushCurrent();
     return geminiMessages;
   }
+  function createFunctionCallPart(call, options) {
+    options.callIdMap?.set(call.id, call.function.name);
+    const context = options.functionCallContextMap?.get(call.id);
+    const part = {
+      functionCall: {
+        ...context?.providerCallId ? { id: context.providerCallId } : {},
+        name: call.function.name,
+        args: JSON.parse(call.function.arguments || "{}")
+      }
+    };
+    if (context?.thoughtSignature) {
+      part.thoughtSignature = context.thoughtSignature;
+    }
+    return part;
+  }
+  function createFunctionResponsePart(msg, options) {
+    const toolCallId = msg.tool_call_id;
+    const context = options.functionCallContextMap?.get(toolCallId);
+    const functionResponse = {
+      ...context?.providerCallId ? { id: context.providerCallId } : {},
+      name: msg.name ?? context?.name ?? options.callIdMap?.get(toolCallId) ?? "result",
+      response: normalizeToolResult(safeJsonParse2(msg.content))
+    };
+    return { functionResponse };
+  }
+  function appendFunctionResponse(messages, part) {
+    const previous = messages[messages.length - 1];
+    const isFunctionResponseGroup = previous?.role === "user" && previous.parts.every((item) => item.functionResponse);
+    if (isFunctionResponseGroup) {
+      previous.parts.push(part);
+      return;
+    }
+    messages.push({ role: "user", parts: [part] });
+  }
   function safeJsonParse2(str) {
     try {
       return JSON.parse(str);
@@ -2935,16 +3054,19 @@ If it's in another language, summarize in that language.
      * @param tools Array of tool definitions
      * @param mcpServers Array of MCP server configurations
      */
-    constructor(apiKey, model = MODEL_GEMINI_3_1_FLASH_LITE, visionModel = MODEL_GEMINI_3_1_FLASH_LITE, tools = [], mcpServers = [], responseLength) {
+    constructor(apiKey, model = MODEL_GEMINI_3_1_FLASH_LITE, visionModel = MODEL_GEMINI_3_1_FLASH_LITE, tools = [], mcpServers = [], responseLength, reasoningEffort) {
       /** Provider name */
       this.provider = "gemini";
       this.mcpToolSchemas = [];
       this.mcpSchemasInitialized = false;
       /** id(OpenAI) → name(Gemini) mapping */
       this.callIdMap = /* @__PURE__ */ new Map();
+      /** Common tool id → Gemini function-call metadata required for replay. */
+      this.functionCallContextMap = /* @__PURE__ */ new Map();
       this.apiKey = apiKey;
       this.model = model;
       this.responseLength = responseLength;
+      this.reasoningEffort = reasoningEffort;
       if (!GEMINI_VISION_SUPPORTED_MODELS.includes(visionModel)) {
         throw new Error(
           `Model ${visionModel} does not support vision capabilities.`
@@ -2957,8 +3079,21 @@ If it's in another language, summarize in that language.
     isGemma4Model(model) {
       return /^gemma-4-/.test(model);
     }
-    shouldMinimizeThinking(model) {
-      return model === MODEL_GEMINI_3_5_FLASH || this.isGemma4Model(model);
+    resolveThinkingConfig(model) {
+      const effort = normalizeGeminiReasoningEffort(model, this.reasoningEffort);
+      if (effort) {
+        return {
+          includeThoughts: false,
+          thinkingLevel: effort.toUpperCase()
+        };
+      }
+      if (this.isGemma4Model(model)) {
+        return {
+          includeThoughts: false,
+          thinkingLevel: "MINIMAL"
+        };
+      }
+      return void 0;
     }
     shouldExposeTextPart(part, model) {
       if (!part.text) return false;
@@ -2976,7 +3111,8 @@ If it's in another language, summarize in that language.
         functionCallingConfig: "function_calling_config",
         functionDeclarations: "function_declarations",
         functionCall: "function_call",
-        functionResponse: "function_response"
+        functionResponse: "function_response",
+        thoughtSignature: "thought_signature"
       };
       if (Array.isArray(obj)) return obj.map((v) => this.adaptKeysForApi(v));
       if (obj && typeof obj === "object") {
@@ -3136,10 +3272,12 @@ If it's in another language, summarize in that language.
       const contents = hasVision ? await convertVisionMessagesToGeminiFormat(
         messages,
         {
-          callIdMap: this.callIdMap
+          callIdMap: this.callIdMap,
+          functionCallContextMap: this.functionCallContextMap
         }
       ) : convertMessagesToGeminiFormat(messages, {
-        callIdMap: this.callIdMap
+        callIdMap: this.callIdMap,
+        functionCallContextMap: this.functionCallContextMap
       });
       const body = {
         contents,
@@ -3147,11 +3285,9 @@ If it's in another language, summarize in that language.
           maxOutputTokens: maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength)
         }
       };
-      if (this.shouldMinimizeThinking(model)) {
-        body.generationConfig.thinkingConfig = {
-          includeThoughts: false,
-          thinkingLevel: "MINIMAL"
-        };
+      const thinkingConfig = this.resolveThinkingConfig(model);
+      if (thinkingConfig) {
+        body.generationConfig.thinkingConfig = thinkingConfig;
       }
       let activeMCPToolSchemas = [];
       if (this.mcpServers.length > 0) {
@@ -3208,6 +3344,32 @@ If it's in another language, summarize in that language.
         throw error;
       }
     }
+    createFunctionCallBlock(part) {
+      const functionCall = part.functionCall ?? part.function_call;
+      if (!functionCall) return void 0;
+      const toolUseId = functionCall.id ?? this.genUUID();
+      this.callIdMap.set(toolUseId, functionCall.name);
+      this.functionCallContextMap.set(toolUseId, {
+        name: functionCall.name,
+        providerCallId: functionCall.id,
+        thoughtSignature: part.thoughtSignature ?? part.thought_signature
+      });
+      return {
+        type: "tool_use",
+        id: toolUseId,
+        name: functionCall.name,
+        input: functionCall.args ?? {}
+      };
+    }
+    createFunctionResponseBlock(part) {
+      const functionResponse = part.functionResponse ?? part.function_response;
+      if (!functionResponse) return void 0;
+      return {
+        type: "tool_result",
+        tool_use_id: functionResponse.id ?? functionResponse.name,
+        content: JSON.stringify(functionResponse.response)
+      };
+    }
     /* ────────────────────────────────────────────────────────── */
     /*  Convert NDJSON stream to common format             */
     /* ────────────────────────────────────────────────────────── */
@@ -3231,21 +3393,10 @@ If it's in another language, summarize in that language.
               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)
-              });
-            }
+            const functionCallBlock = this.createFunctionCallBlock(part);
+            if (functionCallBlock) toolBlocks.push(functionCallBlock);
+            const functionResponseBlock = this.createFunctionResponseBlock(part);
+            if (functionResponseBlock) toolBlocks.push(functionResponseBlock);
           }
         }
       };
@@ -3285,21 +3436,10 @@ If it's in another language, summarize in that language.
           if (this.shouldExposeTextPart(part, model)) {
             textBlocks.push({ type: "text", text: part.text });
           }
-          if (part.functionCall) {
-            toolBlocks.push({
-              type: "tool_use",
-              id: this.genUUID(),
-              name: part.functionCall.name,
-              input: part.functionCall.args ?? {}
-            });
-          }
-          if (part.functionResponse) {
-            toolBlocks.push({
-              type: "tool_result",
-              tool_use_id: part.functionResponse.name,
-              content: JSON.stringify(part.functionResponse.response)
-            });
-          }
+          const functionCallBlock = this.createFunctionCallBlock(part);
+          if (functionCallBlock) toolBlocks.push(functionCallBlock);
+          const functionResponseBlock = this.createFunctionResponseBlock(part);
+          if (functionResponseBlock) toolBlocks.push(functionResponseBlock);
         }
       }
       const blocks = [...textBlocks, ...toolBlocks];
@@ -3349,21 +3489,28 @@ If it's in another language, summarize in that language.
      * @returns GeminiChatService instance
      */
     createChatService(options) {
+      const model = options.model || this.getDefaultModel();
+      if (options.reasoning_effort !== void 0 && !isGeminiReasoningEffortModel(model)) {
+        throw new Error(
+          `Model ${model} does not support Gemini reasoning_effort. Use it with Gemini 3 thinkingLevel models; Gemini 2.5 models use thinkingBudget instead.`
+        );
+      }
       const visionModel = resolveVisionModel({
-        model: options.model,
+        model,
         visionModel: options.visionModel,
         defaultModel: this.getDefaultModel(),
         defaultVisionModel: this.getDefaultModel(),
-        supportsVisionForModel: (model) => this.supportsVisionForModel(model),
+        supportsVisionForModel: (model2) => this.supportsVisionForModel(model2),
         validate: "resolved"
       });
       return new GeminiChatService(
         options.apiKey,
-        options.model || this.getDefaultModel(),
+        model,
         visionModel,
         options.tools || [],
         options.mcpServers || [],
-        options.responseLength
+        options.responseLength,
+        normalizeGeminiReasoningEffort(model, options.reasoning_effort)
       );
     }
     /**
@@ -3571,7 +3718,7 @@ If it's in another language, summarize in that language.
      * @param model Name of the model to use
      * @param visionModel Name of the vision model
      */
-    constructor(apiKey, model = MODEL_KIMI_K2_6, visionModel = MODEL_KIMI_K2_6, tools, endpoint = ENDPOINT_KIMI_CHAT_COMPLETIONS_API, responseLength, responseFormat, thinking) {
+    constructor(apiKey, model = MODEL_KIMI_K2_6, visionModel = MODEL_KIMI_K2_6, tools, endpoint = ENDPOINT_KIMI_CHAT_COMPLETIONS_API, responseLength, responseFormat, thinking, reasoningEffort) {
       /** Provider name */
       this.provider = "kimi";
       this.apiKey = apiKey;
@@ -3580,7 +3727,14 @@ If it's in another language, summarize in that language.
       this.endpoint = endpoint;
       this.responseLength = responseLength;
       this.responseFormat = responseFormat;
-      this.thinking = thinking ?? { type: "enabled" };
+      this.thinking = thinking;
+      const supportedReasoningEfforts = getKimiSupportedReasoningEfforts(model);
+      if (reasoningEffort !== void 0 && !supportedReasoningEfforts.includes(reasoningEffort)) {
+        throw new Error(
+          `Model ${model} does not support reasoning_effort: ${reasoningEffort}.`
+        );
+      }
+      this.reasoningEffort = reasoningEffort ?? (isKimiReasoningEffortModel(model) ? supportedReasoningEfforts[0] : void 0);
       this.visionModel = visionModel;
     }
     /**
@@ -3601,10 +3755,7 @@ If it's in another language, summarize in that language.
     async processChat(messages, onPartialResponse, onCompleteResponse) {
       await processChatWithOptionalTools({
         hasTools: this.tools.length > 0,
-        runWithoutTools: async () => {
-          const res = await this.callKimi(messages, this.model, true);
-          return this.handleStream(res, onPartialResponse);
-        },
+        runWithoutTools: () => this.chatOnce(messages, true, onPartialResponse),
         runWithTools: () => this.chatOnce(messages, true, onPartialResponse),
         onCompleteResponse,
         toolErrorMessage: "processChat received tool_calls. ChatProcessor must use chatOnce() loop when tools are enabled."
@@ -3621,10 +3772,7 @@ If it's in another language, summarize in that language.
       }
       await processChatWithOptionalTools({
         hasTools: this.tools.length > 0,
-        runWithoutTools: async () => {
-          const res = await this.callKimi(messages, this.visionModel, true);
-          return this.handleStream(res, onPartialResponse);
-        },
+        runWithoutTools: () => this.visionChatOnce(messages, true, onPartialResponse),
         runWithTools: () => this.visionChatOnce(messages, true, onPartialResponse),
         onCompleteResponse,
         toolErrorMessage: "processVisionChat received tool_calls. ChatProcessor must use visionChatOnce() loop when tools are enabled."
@@ -3677,11 +3825,18 @@ If it's in another language, summarize in that language.
       };
       const tokenLimit = maxTokens !== void 0 ? maxTokens : getMaxTokensForResponseLength(this.responseLength);
       if (tokenLimit !== void 0) {
-        body.max_tokens = tokenLimit;
+        if (isKimiReasoningEffortModel(model)) {
+          body.max_completion_tokens = tokenLimit;
+        } else {
+          body.max_tokens = tokenLimit;
+        }
       }
       if (this.responseFormat) {
         body.response_format = this.responseFormat;
       }
+      if (isKimiReasoningEffortModel(model)) {
+        body.reasoning_effort = this.reasoningEffort ?? "max";
+      }
       const effectiveThinking = this.resolveEffectiveThinking(model);
       if (effectiveThinking) {
         if (this.isSelfHostedEndpoint()) {
@@ -3706,6 +3861,14 @@ If it's in another language, summarize in that language.
       return value.replace(/\/+$/, "");
     }
     resolveEffectiveThinking(model) {
+      if (isKimiReasoningEffortModel(model)) {
+        if (this.thinking) {
+          throw new Error(
+            `Model ${model} uses reasoning_effort and does not support the K2.x thinking option.`
+          );
+        }
+        return void 0;
+      }
       if (isKimiThinkingRequiredModel(model)) {
         if (this.thinking?.type === "disabled") {
           throw new Error(
@@ -3717,21 +3880,17 @@ If it's in another language, summarize in that language.
       if (this.tools.length > 0) {
         return { type: "disabled" };
       }
-      return this.thinking;
+      return this.thinking ?? { type: "enabled" };
     }
     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, {
+        preserveAssistantMessage: true,
         onJsonError: (payload) => console.debug("Failed to parse SSE data:", payload)
       });
     }
@@ -3739,7 +3898,9 @@ If it's in another language, summarize in that language.
      * Parse non-streaming response
      */
     parseOneShot(data) {
-      return parseOpenAICompatibleOneShot(data);
+      return parseOpenAICompatibleOneShot(data, {
+        preserveAssistantMessage: true
+      });
     }
   };
 
@@ -3764,6 +3925,10 @@ If it's in another language, summarize in that language.
       });
       const tools = options.tools;
       const thinking = this.resolveThinking(model, tools, options.thinking);
+      const reasoningEffort = this.resolveReasoningEffort(
+        model,
+        options.reasoning_effort
+      );
       return new KimiChatService(
         options.apiKey,
         model,
@@ -3772,7 +3937,8 @@ If it's in another language, summarize in that language.
         endpoint,
         options.responseLength,
         options.responseFormat,
-        thinking
+        thinking,
+        reasoningEffort
       );
     }
     /**
@@ -3786,6 +3952,7 @@ If it's in another language, summarize in that language.
      */
     getSupportedModels() {
       return [
+        MODEL_KIMI_K3,
         MODEL_KIMI_K2_7_CODE,
         MODEL_KIMI_K2_7_CODE_HIGHSPEED,
         MODEL_KIMI_K2_6,
@@ -3839,6 +4006,14 @@ If it's in another language, summarize in that language.
       return value.replace(/\/+$/, "");
     }
     resolveThinking(model, tools, thinking) {
+      if (isKimiReasoningEffortModel(model)) {
+        if (thinking) {
+          throw new Error(
+            `Model ${model} uses reasoning_effort and does not support the K2.x thinking option.`
+          );
+        }
+        return void 0;
+      }
       if (isKimiThinkingRequiredModel(model)) {
         if (thinking?.type === "disabled") {
           throw new Error(
@@ -3852,6 +4027,24 @@ If it's in another language, summarize in that language.
       }
       return thinking ?? this.defaultThinking;
     }
+    resolveReasoningEffort(model, reasoningEffort) {
+      const supported = getKimiSupportedReasoningEfforts(model);
+      if (supported.length === 0) {
+        if (reasoningEffort !== void 0) {
+          throw new Error(
+            `Model ${model} does not support the reasoning_effort option.`
+          );
+        }
+        return void 0;
+      }
+      const resolved = reasoningEffort ?? supported[0];
+      if (!supported.includes(resolved)) {
+        throw new Error(
+          `Model ${model} supports reasoning_effort values: ${supported.join(", ")}.`
+        );
+      }
+      return resolved;
+    }
   };
 
   // src/services/providers/mistral/MistralChatService.ts
@@ -5258,6 +5451,7 @@ If it's in another language, summarize in that language.
   ]);
   var REASONING_EFFORT_BY_PROVIDER = {
     openai: ["none", "minimal", "low", "medium", "high", "xhigh", "max"],
+    gemini: ["minimal", "low", "medium", "high"],
     openrouter: ["none", "minimal", "low", "medium", "high"],
     mistral: ["low", "medium", "high"],
     plamo: ["none", "medium"],