OpenRouter interleaved reasoning forwarding for tool-call continuations (#5160) * fix(openrouter): forward reasoning across active tool-call chains * feat(reasoning): add tool-chain forwarding toggle and honor edited reasoning * feat(reasoning): add OpenRouter interleaved forwarding modes * moved the reasoning forwarding dropdown into a separate line * feat(reasoning): default tool reasoning forwarding to disabled * refactor(openrouter): move tool reasoning mode to CC settings Move OpenRouter tool reasoning forwarding control to response configuration and scope it to OpenRouter. Store mode in chat completion settings (presettable), remove legacy power_user boolean/fallback, and use constants for mode values. Preserve OpenRouter Gemini signature forwarding independently from plaintext tool reasoning mode. * fix(openrouter): tighten active-chain reasoning forwarding Use trailing contiguous tool-chain boundary for active-chain eligibility. Also rename the UI control to Interleaved Thinking Forwarding and place selector on its own line. * fix(openrouter): use adjacent assistant reasoning for tool calls For interleaved thinking forwarding, source reasoning only from the immediately preceding assistant non-tool message. Keep mode gating behavior unchanged and avoid history-window reasoning carryover. * fix(openrouter): skip tool messages for reasoning source When forwarding interleaved reasoning, ignore intervening tool result messages when resolving the preceding assistant reasoning source. This keeps only the first tool call in a chain tied to a prior assistant reasoning block unless a later invocation carries its own reasoning. * fix(openrouter): keep plaintext reasoning with signatures Do not suppress forwarded tool-call reasoning when thought signatures are present. * fix(openrouter): split interleaved thinking mode behavior Restore distinct mode semantics: active_chain uses nearest assistant-text boundary after skipping tool/tool-call messages, while since_last_user scans for latest assistant reasoning since user. Update UI label to Interleaved Thinking with right-aligned dropdown and explanatory tooltip. * style(openrouter): align interleaved thinking dropdown row Match OpenRouter interleaved thinking control layout with existing oneline-dropdown patterns. Also update reasoning-forwarding inline comment wording for current mode behavior. * docs(ui): clarify interleaved thinking tooltip Use explicit API-request wording for OpenRouter interleaved thinking tooltip text. * i18n(openrouter): localize interleaved thinking UI Add locale keys for OpenRouter interleaved thinking label, mode options, and inline helper description. Wire dropdown option text to data-i18n in index.html. * fixed helper text wrapping * fix(ui): make interleaved thinking helper text wrap * i18n(openrouter): translate interleaved thinking labels Replace placeholder English values for interleaved thinking keys in non-English locale files. * fix(ui): restore interleaved thinking dropdown alignment * Remove changes from en.json * Type fixes * Reworked the interleaved reasoning provider logic * Renamed the variables in preparation for potential implementation for other providers * Gate interleaved tool reasoning on reasoning request setting --------- Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

0ba0418facda00b98ac0a124dfdb7eead917a9d5

ZhenyaPav <61346893+ZhenyaPav@users.noreply.github.com>

Signed

Parents: 8462cbaebb9d74ae3db7d534571fa0f15f2ce960

public/index.html+24 -0 Viewed

                                             <strong data-i18n="enable_functions_desc_4">Not supported when Prompt Post-Processing with "no tools" is used!</strong>
                                         </div>
                                     </div>
+                                    <div class="range-block" data-source="openrouter">
+                                        <div class="flex-container flexFlowColumn wide100p textAlignCenter marginTop10">
+                                            <div class="flex-container oneline-dropdown">
+                                                <label for="tool_reasoning_mode" data-i18n="Interleaved Thinking">
+                                                    Interleaved Thinking
+                                                </label>
+                                                <select id="tool_reasoning_mode">
+                                                    <option data-i18n="Disabled" value="disabled">Disabled</option>
+                                                    <option data-i18n="Since Last User Message" value="since_last_user">Since Last User Message</option>
+                                                    <option data-i18n="Active Tool Chain" value="active_chain">Active Tool Chain</option>
+                                                </select>
+                                            </div>
+                                        </div>
+                                        <div class="toggle-description justifyLeft">
+                                            <span data-i18n="openrouter_interleaved_thinking_hint">
+                                                Sends reasoning from preceding assistant turns with tool-call requests to maintain interleaved thinking context.
+                                            </span>
+                                        </div>
+                                        <div id="openrouter_interleaved_thinking_disabled_hint" class="toggle-description justifyLeft" style="display:none;">
+                                            <em data-i18n="Enable &quot;Request model reasoning&quot; to use Interleaved Thinking.">
+                                                Enable "Request model reasoning" to use Interleaved Thinking.
+                                            </em>
+                                        </div>
+                                    </div>
                                     <div class="range-block" data-source="openai,aimlapi,openrouter,mistralai,makersuite,vertexai,claude,custom,xai,pollinations,moonshot,cohere,cometapi,nanogpt,electronhub,azure_openai,zai,siliconflow,chutes">
                                         <label for="openai_media_inlining" class="checkbox_label flexWrap widthFreeExpand">
                                             <input id="openai_media_inlining" type="checkbox" />

public/locales/ar-sa.json+5 -1 Viewed

     "Still have questions?": "هل ما زالت لديك اسئلة؟",
     "Join the SillyTavern Discord": "انضم إلى ديسكورد SillyTavern",
     "Post a GitHub issue": "نشر مشكلة على GitHub",
-    "Contact the developers": "الاتصال بالمطورين"
+    "Contact the developers": "الاتصال بالمطورين",
+    "Interleaved Thinking": "التفكير المتداخل",
+    "Since Last User Message": "منذ آخر رسالة من المستخدم",
+    "Active Tool Chain": "سلسلة الأدوات النشطة",
+    "openrouter_interleaved_thinking_hint": "يرسل الاستدلال من رسائل المساعد السابقة مع طلبات استدعاء الأدوات للحفاظ على سياق التفكير المتداخل."
+}

public/locales/de-de.json+5 -1 Viewed

     "Still have questions?": "Hast du immer noch Fragen?",
     "Join the SillyTavern Discord": "Trete dem SillyTavern Discord bei",
     "Post a GitHub issue": "Veröffentliche ein GitHub-Problem",
-    "Contact the developers": "Kontaktiere die Entwickler"
+    "Contact the developers": "Kontaktiere die Entwickler",
+    "Interleaved Thinking": "Verschränktes Denken",
+    "Since Last User Message": "Seit letzter Nutzernachricht",
+    "Active Tool Chain": "Aktive Tool-Kette",
+    "openrouter_interleaved_thinking_hint": "Sendet Begründungen aus vorherigen Assistentennachrichten mit Tool-Aufrufen, um den Kontext für verschränktes Denken zu erhalten."
+}

public/locales/es-es.json+5 -1 Viewed

     "Toggles sharing world tint with character sprites (This will override Character Tint)": "Alterna el tinte mundial compartido con los sprites de personajes (esto anulará el tinte de personajes)",
     "Sets the expression of the user sprite": "Establece la expresión del sprite de usuario",
     "Sets the user sprite set to use for the user sprite": "Establece el conjunto de sprites de usuario para usar en el sprite de usuario",
-    "Toggles the user sprite on the VN UI": "Alterna el sprite de usuario en la interfaz VN"
+    "Toggles the user sprite on the VN UI": "Alterna el sprite de usuario en la interfaz VN",
+    "Interleaved Thinking": "Razonamiento intercalado",
+    "Since Last User Message": "Desde el último mensaje del usuario",
+    "Active Tool Chain": "Cadena de herramientas activa",
+    "openrouter_interleaved_thinking_hint": "Envía razonamiento de turnos anteriores del asistente junto con solicitudes de herramientas para mantener el contexto del razonamiento intercalado."
+}

public/locales/fr-fr.json+5 -1 Viewed

     "System Prompt Name": "Nom du prompt système:",
     "Instruct Mode": "Mode Instruction:",
     "Save and Update": "Sauvegarder et mettre à jour",
-    "Don't ask again for this URL": "Ne plus demander pour cette URL"
+    "Don't ask again for this URL": "Ne plus demander pour cette URL",
+    "Interleaved Thinking": "Raisonnement intercalé",
+    "Since Last User Message": "Depuis le dernier message utilisateur",
+    "Active Tool Chain": "Chaîne d'outils active",
+    "openrouter_interleaved_thinking_hint": "Envoie le raisonnement des tours précédents de l'assistant avec les requêtes d'outils pour conserver le contexte du raisonnement intercalé."
+}

public/locales/is-is.json+5 -1 Viewed

     "Still have questions?": "Ertu enn með spurningar?",
     "Join the SillyTavern Discord": "Skráðu þig í SillyTavern Discord",
     "Post a GitHub issue": "Senda inn GitHub málefni",
-    "Contact the developers": "Hafa samband við þróunaraðila"
+    "Contact the developers": "Hafa samband við þróunaraðila",
+    "Interleaved Thinking": "Fléttuð hugsun",
+    "Since Last User Message": "Frá síðustu notandaskilaboðum",
+    "Active Tool Chain": "Virk verkfærakeðja",
+    "openrouter_interleaved_thinking_hint": "Sendir röksemdir úr fyrri aðstoðarskilaboðum með verkfæraköllum til að viðhalda samhengi fléttaðrar hugsunar."
+}

public/locales/it-it.json+5 -1 Viewed

     "Still have questions?": "Hai ancora domande?",
     "Join the SillyTavern Discord": "Unisciti al SillyTavern Discord",
     "Post a GitHub issue": "Pubblica un problema su GitHub",
-    "Contact the developers": "Contatta gli sviluppatori"
+    "Contact the developers": "Contatta gli sviluppatori",
+    "Interleaved Thinking": "Ragionamento intercalato",
+    "Since Last User Message": "Dall'ultimo messaggio utente",
+    "Active Tool Chain": "Catena di strumenti attiva",
+    "openrouter_interleaved_thinking_hint": "Invia il ragionamento dai turni precedenti dell'assistente con le richieste di strumenti per mantenere il contesto del ragionamento intercalato."
+}

public/locales/ja-jp.json+5 -1 Viewed

     "Contact the developers": "開発者に連絡",
     "Stop Inspecting": "検査を停止",
     "Inspect Prompts": "プロンプトを検査",
-    "Toggle prompt inspection": "プロンプト検査の切り替え"
+    "Toggle prompt inspection": "プロンプト検査の切り替え",
+    "Interleaved Thinking": "インターリーブ思考",
+    "Since Last User Message": "直前のユーザーメッセージ以降",
+    "Active Tool Chain": "アクティブなツールチェーン",
+    "openrouter_interleaved_thinking_hint": "インターリーブ思考の文脈を維持するため、直前のアシスタントターンの推論をツール呼び出しリクエストとともに送信します。"
+}

public/locales/ko-kr.json+5 -1 Viewed

     "to install additional features.": "으로 가세요.",
     "Master Import": "마스터 불러오기",
     "Master Export": "마스터 내보내기",
-    "Chat Quick Reply Sets": "채팅 빠른 답장 세트들"
+    "Chat Quick Reply Sets": "채팅 빠른 답장 세트들",
+    "Interleaved Thinking": "인터리브드 사고",
+    "Since Last User Message": "마지막 사용자 메시지 이후",
+    "Active Tool Chain": "활성 도구 체인",
+    "openrouter_interleaved_thinking_hint": "인터리브드 사고 컨텍스트를 유지하기 위해 이전 어시스턴트 턴의 추론을 도구 호출 요청과 함께 전송합니다."
+}

public/locales/nl-nl.json+5 -1 Viewed

     "Still have questions?": "Heb je nog vragen?",
     "Join the SillyTavern Discord": "Word lid van de SillyTavern Discord",
     "Post a GitHub issue": "Plaats een GitHub-probleem",
-    "Contact the developers": "Neem contact op met de ontwikkelaars"
+    "Contact the developers": "Neem contact op met de ontwikkelaars",
+    "Interleaved Thinking": "Verweven redenering",
+    "Since Last User Message": "Sinds laatste gebruikersbericht",
+    "Active Tool Chain": "Actieve toolketen",
+    "openrouter_interleaved_thinking_hint": "Verstuurt redenering uit eerdere assistentbeurten met tool-aanvragen om de context van verweven redenering te behouden."
+}

public/locales/pt-pt.json+5 -1 Viewed

     "Still have questions?": "Ainda tem perguntas?",
     "Join the SillyTavern Discord": "Junte-se ao Discord do SillyTavern",
     "Post a GitHub issue": "Publicar um problema no GitHub",
-    "Contact the developers": "Contatar os desenvolvedores"
+    "Contact the developers": "Contatar os desenvolvedores",
+    "Interleaved Thinking": "Raciocínio intercalado",
+    "Since Last User Message": "Desde a última mensagem do utilizador",
+    "Active Tool Chain": "Cadeia de ferramentas ativa",
+    "openrouter_interleaved_thinking_hint": "Envia o raciocínio de turnos anteriores do assistente com pedidos de ferramentas para manter o contexto de raciocínio intercalado."
+}

public/locales/ru-ru.json+5 -1 Viewed

     "Uses the voices provided by your operating system": "Используем стандартные голоса вашей ОС",
     "Your browser or operating system doesn't support speech synthesis": "Ваш браузер либо ОС не поддерживают синтез речи",
     "Works best when: Pass Asterisks to TTS Engine is enabled, and both Only narrate quotes and Ignore *text, even 'quotes', inside asterisks* are disabled.": "Работает лучше всего, когда: одновременно включена опция \"Передавать звёздочки TTS-движку\", а также отключены обе опции: \"Не озвучивать *текст, даже \"в кавычках\", если он внутри звёздочек*\", и \"Озвучивать только текст \"в кавычках\"\"",
-    "Available voices": "Доступные голоса"
+    "Available voices": "Доступные голоса",
+    "Interleaved Thinking": "Чередующееся рассуждение",
+    "Since Last User Message": "С момента последнего сообщения пользователя",
+    "Active Tool Chain": "Активная цепочка инструментов",
+    "openrouter_interleaved_thinking_hint": "Отправляет рассуждение из предыдущих ходов ассистента вместе с запросами вызова инструментов, чтобы сохранять контекст чередующегося рассуждения."
+}

public/locales/th-th.json+5 -1 Viewed

   "Contact the developers": "ติดต่อผู้พัฒนา",
   "Stop Inspecting": "Stop Inspecting",
   "Inspect Prompts": "ตรวจสอบ Prompt",
-  "Toggle prompt inspection": "สลับการตรวจสอบ Prompt"
+  "Toggle prompt inspection": "สลับการตรวจสอบ Prompt",
+    "Interleaved Thinking": "การคิดแบบสลับขั้น",
+    "Since Last User Message": "ตั้งแต่ข้อความล่าสุดของผู้ใช้",
+    "Active Tool Chain": "สายโซ่เครื่องมือที่ใช้งานอยู่",
+    "openrouter_interleaved_thinking_hint": "ส่งเหตุผลจากเทิร์นก่อนหน้าของผู้ช่วยไปพร้อมกับคำขอเรียกใช้เครื่องมือ เพื่อคงบริบทการคิดแบบสลับขั้นไว้"
+}

public/locales/uk-ua.json+5 -1 Viewed

     "Still have questions?": "Все ще є питання?",
     "Join the SillyTavern Discord": "Приєднуйтесь до SillyTavern Discord",
     "Post a GitHub issue": "Опублікуйте проблему на GitHub",
-    "Contact the developers": "Зв'яжіться з розробниками"
+    "Contact the developers": "Зв'яжіться з розробниками",
+    "Interleaved Thinking": "Черговане мислення",
+    "Since Last User Message": "Від останнього повідомлення користувача",
+    "Active Tool Chain": "Активний ланцюжок інструментів",
+    "openrouter_interleaved_thinking_hint": "Надсилає міркування з попередніх ходів асистента разом із запитами виклику інструментів, щоб зберегти контекст чергованого мислення."
+}

public/locales/vi-vn.json+5 -1 Viewed

     "Still have questions?": "Bạn còn thắc mắc?",
     "Join the SillyTavern Discord": "Tham gia Kênh Discord của SillyTavern",
     "Post a GitHub issue": "Đăng một vấn đề trên GitHub",
-    "Contact the developers": "Liên hệ với Devs"
+    "Contact the developers": "Liên hệ với Devs",
+    "Interleaved Thinking": "Lập luận xen kẽ",
+    "Since Last User Message": "Kể từ tin nhắn người dùng gần nhất",
+    "Active Tool Chain": "Chuỗi công cụ đang hoạt động",
+    "openrouter_interleaved_thinking_hint": "Gửi lập luận từ các lượt trợ lý trước đó cùng với yêu cầu gọi công cụ để duy trì ngữ cảnh lập luận xen kẽ."
+}

public/locales/zh-cn.json+4 -0 Viewed

     "Title/Memo": "标题（备忘）",
     "Strategy": "触发策略",
     "Trigger %": "触发概率 %",
+    "Interleaved Thinking": "交错思维",
+    "Since Last User Message": "自上一条用户消息起",
+    "Active Tool Chain": "活动工具链",
+    "openrouter_interleaved_thinking_hint": "发送前面助手轮次的推理并附在工具调用请求中，以维持交错思维上下文。",
     "Class": "类型",
     "Context Length": "上下文长度",
     "Added On": "添加于",

public/locales/zh-tw.json+5 -1 Viewed

     "[title]Create a new": "新增",
     "[title]Delete a ": "刪除 ",
     "[title]Rename a ": "重新命名 ",
-    "completions note prefix": "完成提示前綴"
+    "completions note prefix": "完成提示前綴",
+    "Interleaved Thinking": "交錯思維",
+    "Since Last User Message": "自上一則使用者訊息起",
+    "Active Tool Chain": "使用中的工具鏈",
+    "openrouter_interleaved_thinking_hint": "會在工具呼叫請求中附帶先前助理回合的推理，以維持交錯思維的上下文。"
+}

public/script.js+4 -2 Viewed

                 const hasToolCalls = ToolManager.hasToolCalls(streamingProcessor.toolCalls);
                 const shouldDeleteMessage = type !== 'swipe' && ['', '...'].includes(lastMessage?.mes) && !lastMessage?.extra?.reasoning && ['', '...'].includes(streamingProcessor?.result);
                 hasToolCalls && shouldDeleteMessage && await deleteLastMessage();
-                const invocationResult = await ToolManager.invokeFunctionTools(streamingProcessor.toolCalls);
+                const invocationResult = await ToolManager.invokeFunctionTools(streamingProcessor.toolCalls, {
+                    reasoningText: streamingProcessor.reasoningHandler.reasoning,
+                });
                 const shouldStopGeneration = (!invocationResult.invocations.length && shouldDeleteMessage) || invocationResult.stealthCalls.length;
                 if (hasToolCalls) {
                     if (shouldStopGeneration) {

             const hasToolCalls = ToolManager.hasToolCalls(data);
             const shouldDeleteMessage = type !== 'swipe' && ['', '...'].includes(getMessage) && !reasoning;
             hasToolCalls && shouldDeleteMessage && await deleteLastMessage();
-            const invocationResult = await ToolManager.invokeFunctionTools(data);
+            const invocationResult = await ToolManager.invokeFunctionTools(data, { reasoningText: reasoning });
             const shouldStopGeneration = (!invocationResult.invocations.length && shouldDeleteMessage) || invocationResult.stealthCalls.length;
             if (hasToolCalls) {
                 if (shouldStopGeneration) {

public/scripts/openai.js+151 -12 Viewed

     high: 'high',
 };
+export const tool_reasoning_modes = {
+    DISABLED: 'disabled',
+    SINCE_LAST_USER: 'since_last_user',
+    ACTIVE_CHAIN: 'active_chain',
+};
+// Providers that support interleaved reasoning forwarding in tool-call chains.
+const interleaved_reasoning_providers = [
+    chat_completion_sources.OPENROUTER,
+];
 export const ZAI_ENDPOINT = {
     COMMON: 'common',
     CODING: 'coding',

     openrouter_quantizations: ['#openrouter_quantizations_chat', 'openrouter_quantizations', false, true],
     openrouter_allow_fallbacks: ['#openrouter_allow_fallbacks', 'openrouter_allow_fallbacks', true, true],
     openrouter_middleout: ['#openrouter_middleout', 'openrouter_middleout', false, true],
+    tool_reasoning_mode: ['#tool_reasoning_mode', 'tool_reasoning_mode', false, false],
     ai21_model: ['#model_ai21_select', 'ai21_model', false, true],
     mistralai_model: ['#model_mistralai_select', 'mistralai_model', false, true],
     cohere_model: ['#model_cohere_select', 'cohere_model', false, true],

     openrouter_quantizations: [],
     openrouter_allow_fallbacks: true,
     openrouter_middleout: openrouter_middleout_types.ON,
+    tool_reasoning_mode: tool_reasoning_modes.DISABLED,
     reverse_proxy: '',
     chat_completion_source: chat_completion_sources.OPENAI,
     max_context_unlocked: false,

         const originModel = chat[j]?.extra?.model;
         const isSameModel = originApi === currentApi && originModel === currentModel;
         const signature = isSameModel ? chat[j]?.extra?.reasoning_signature : null;
+        const reasoning = isSameModel ? String(chat[j]?.extra?.reasoning ?? '') : '';
-        // Remove signatures from invocations if the API/model don't match
+        // Remove reasoning metadata from invocations if the API/model don't match
         if (Array.isArray(invocations) && invocations.length > 0) {
             invocations.forEach((invocation, index) => {
-                if (invocation.signature && !isSameModel) {
+                if (!isSameModel && (invocation.signature || invocation.reasoning)) {
                     const cloneInvocation = structuredClone(invocation);
                     delete cloneInvocation.signature;
+                    delete cloneInvocation.reasoning;
                     invocations[index] = cloneInvocation;
+                }
             });
+        }
-        messages[i] = { 'role': role, 'content': content, name: name, 'media': media, 'mediaDisplay': mediaDisplay, 'mediaIndex': mediaIndex, 'invocations': invocations, 'signature': signature };
+        messages[i] = { 'role': role, 'content': content, name: name, 'media': media, 'mediaDisplay': mediaDisplay, 'mediaIndex': mediaIndex, 'invocations': invocations, 'signature': signature, 'reasoning': reasoning };
         j++;
+    }

     const audioInlining = isAudioInliningSupported();
     const canUseTools = ToolManager.isToolCallingSupported();
     const includeSignature = isReasoningSignatureSupported();
+    const isToolReasoningProvider = interleaved_reasoning_providers.includes(oai_settings.chat_completion_source);
+    const toolReasoningMode = isToolReasoningProvider
+        ? getEffectiveToolReasoningMode()
+        : tool_reasoning_modes.DISABLED;
+    const includeToolReasoning = toolReasoningMode !== tool_reasoning_modes.DISABLED;
+    const lastUserIdx = messages.findLastIndex(x => x.role === 'user');
     // Insert chat messages as long as there is budget available
     const chatPool = [...messages].reverse();

+        }
         if (canUseTools && Array.isArray(chatPrompt.invocations)) {
+            const promptIdx = messages.indexOf(chatPrompt);
+            const reasoningIsEligible = toolReasoningMode !== tool_reasoning_modes.DISABLED
+                && promptIdx > lastUserIdx;
+            let previousAssistantReasoning = '';
+            if (reasoningIsEligible) {
+                if (toolReasoningMode === tool_reasoning_modes.ACTIVE_CHAIN) {
+                    // Strict chain mode: skip tool/tool-call messages, then use only the first assistant text boundary.
+                    for (let idx = promptIdx - 1; idx > lastUserIdx; idx--) {
+                        const candidate = messages[idx];
+                        if (candidate?.role === 'tool') {
+                            continue;
+                        }
+                        if (candidate?.role === 'assistant' && Array.isArray(candidate.invocations)) {
+                            continue;
+                        }
+                        const hasAssistantText = candidate?.role === 'assistant'
+                            && !Array.isArray(candidate.invocations)
+                            && typeof candidate.content === 'string'
+                            && candidate.content.trim().length > 0;
+                        if (hasAssistantText) {
+                            previousAssistantReasoning = String(candidate.reasoning ?? '');
+                        }
+                        break;
+                    }
+                } else if (toolReasoningMode === tool_reasoning_modes.SINCE_LAST_USER) {
+                    // Broad mode: use the latest assistant text reasoning anywhere since the last user.
+                    for (let idx = promptIdx - 1; idx > lastUserIdx; idx--) {
+                        const candidate = messages[idx];
+                        const hasAssistantText = candidate?.role === 'assistant'
+                            && !Array.isArray(candidate.invocations)
+                            && typeof candidate.content === 'string'
+                            && candidate.content.trim().length > 0;
+                        if (!hasAssistantText) {
+                            continue;
+                        }
+                        const candidateReasoning = String(candidate.reasoning ?? '');
+                        if (candidateReasoning) {
+                            previousAssistantReasoning = candidateReasoning;
+                            break;
+                        }
+                    }
+                }
+            }
             /** @type {import('./tool-calling.js').ToolInvocation[]} */
-            const invocations = chatPrompt.invocations;
+            const invocations = chatPrompt.invocations.map(invocation => {
+                const clone = structuredClone(invocation);
+                if (!reasoningIsEligible) {
+                    delete clone.reasoning;
+                } else if (previousAssistantReasoning) {
+                    // Prefer currently editable assistant-text reasoning based on forwarding mode over invocation snapshot.
+                    clone.reasoning = previousAssistantReasoning;
+                }
+                return clone;
+            });
             const toolCallMessage = await Message.createAsync(chatMessage.role, undefined, 'toolCall-' + chatMessage.identifier);
             const toolResultMessages = await Promise.all(invocations.slice().reverse().map((invocation) => Message.createAsync('tool', invocation.result || '[No content]', invocation.id)));
-            await toolCallMessage.setToolCalls(invocations, includeSignature);
+            await toolCallMessage.setToolCalls(invocations, includeSignature, includeToolReasoning);
             if (chatCompletion.canAffordAll([toolCallMessage, ...toolResultMessages])) {
                 for (const resultMessage of toolResultMessages) {
                     chatCompletion.insertAtStart(resultMessage, 'chatHistory');

             state.images.push(...imageUrls.filter(isDataURL));
+        }
         if (show_thoughts) {
-            state.reasoning += (data.choices?.filter(x => x?.delta?.reasoning)?.[0]?.delta?.reasoning || '');
+            state.reasoning +=
+                data.choices?.filter(x => x?.delta?.reasoning)?.[0]?.delta?.reasoning ??
+                data.choices?.filter(x => x?.delta?.reasoning_content)?.[0]?.delta?.reasoning_content ??
+                data.choices?.filter(x => x?.message?.reasoning)?.[0]?.message?.reasoning ??
+                data.choices?.filter(x => x?.message?.reasoning_content)?.[0]?.message?.reasoning_content ??
+                '';
+        }
-        // Extract thought signatures from OpenRouter streaming (reasoning_details in delta)
+        // Extract thought signatures from OpenRouter streaming.
-        const reasoningDetails = data?.choices?.[0]?.delta?.reasoning_details || [];
+        const reasoningDetails = [
+            ...(data?.choices?.[0]?.delta?.reasoning_details || []),
+            ...(data?.choices?.[0]?.message?.reasoning_details || []),
+        ];
         reasoningDetails.forEach((detail) => {
             if (detail.type === 'reasoning.encrypted' && detail.data) {
-                if (/^tool_/.test(detail.id)) {
+                const isToolLikeId = typeof detail.id === 'string' && /^(tool_|call_)/.test(detail.id);
+                if (typeof detail.id === 'string' && detail.id.length > 0) {
                     state.toolSignatures[detail.id] = detail.data;
-                } else {
+                }
+                if (!isToolLikeId) {
                     state.signature = detail.data;
+                }
+            }

     tool_call = null;
     /** @type {string?} */
     signature = null;
+    /** @type {string?} */
+    reasoning = null;
     /**
      * @constructor

      * Reconstruct the message from a tool invocation.
      * @param {import('./tool-calling.js').ToolInvocation[]} invocations - The tool invocations to reconstruct the message from.
      * @param {boolean} includeSignature Whether to include the signature in the tool calls.
+     * @param {boolean} includeReasoning Whether to include plaintext reasoning fallback.
      * @returns {Promise<void>}
      */
-    async setToolCalls(invocations, includeSignature) {
+    async setToolCalls(invocations, includeSignature, includeReasoning = false) {
         this.tool_calls = invocations.map(i => ({
             id: i.id,
             type: 'function',

             },
             ...(includeSignature && i.signature ? { signature: i.signature } : {}),
         }));
-        this.tokens = await tokenHandler.countAsync({ role: this.role, tool_calls: JSON.stringify(this.tool_calls) });
+        const fallbackReasoning = invocations.find(i => typeof i.reasoning === 'string' && i.reasoning.length > 0)?.reasoning || null;
+        this.reasoning = includeReasoning ? fallbackReasoning : null;
+        this.tokens = await tokenHandler.countAsync({
+            role: this.role,
+            tool_calls: JSON.stringify(this.tool_calls),
+            ...(this.reasoning ? { reasoning: this.reasoning } : {}),
+        });
+    }
     /**

                     ...(message.tool_calls && { tool_calls: message.tool_calls }),
                     ...(message.role === 'tool' && { tool_call_id: message.identifier }),
                     ...(message.signature && { signature: message.signature }),
+                    ...(message.reasoning && { reasoning: message.reasoning }),
                 });
+            }
             return acc;

                     ...(item.tool_calls ? { tool_calls: item.tool_calls } : {}),
                     ...(item.role === 'tool' ? { tool_call_id: item.identifier } : {}),
                     ...(item.signature ? { signature: item.signature } : {}),
+                    ...(item.reasoning ? { reasoning: item.reasoning } : {}),
                 };
                 chat.push(message);
             } else {

     setNamesBehaviorControls();
     setContinuePostfixControls();
+    setToolReasoningControls();
     $('#openrouter_providers_chat').trigger('change');
     $('#openrouter_quantizations_chat').trigger('change');

     $('#continue_postfix_display').text(checkedItemText);
+}
+function setToolReasoningControls() {
+    const isEnabled = oai_settings.show_thoughts;
+    $('#tool_reasoning_mode').prop('disabled', !isEnabled);
+    $('#openrouter_interleaved_thinking_disabled_hint').toggle(!isEnabled);
+}
 async function getStatusOpen() {
     const noValidateSources = [
         chat_completion_sources.CLAUDE,

         const matchesSource = validSources.includes(oai_settings.chat_completion_source);
         $(this).toggle(mode !== 'except' ? matchesSource : !matchesSource);
     });
+    setToolReasoningControls();
+}
 async function testApiConnection() {

+}
 /**
+ * Gets the tool-call reasoning forwarding mode.
+ * @param {ChatCompletionSettings} settings Settings object to use
+ * @returns {string} Reasoning forwarding mode
+ */
+function getToolReasoningMode(settings = oai_settings) {
+    const mode = String(settings.tool_reasoning_mode ?? '');
+    if (Object.values(tool_reasoning_modes).includes(mode)) {
+        return mode;
+    }
+    return tool_reasoning_modes.DISABLED;
+}
+/**
+ * Gets the effective tool-call reasoning forwarding mode.
+ * Interleaved thinking requires explicit reasoning requests.
+ * @param {ChatCompletionSettings} settings Settings object to use
+ * @returns {string} Effective reasoning forwarding mode
+ */
+function getEffectiveToolReasoningMode(settings = oai_settings) {
+    if (!settings.show_thoughts) {
+        return tool_reasoning_modes.DISABLED;
+    }
+    return getToolReasoningMode(settings);
+}
+/**
  * Check if the model supports encrypted reasoning signatures.
  * @param {ChatCompletionSettings} settings Settings object to use
  * @returns {boolean} True if reasoning signatures should be included in the request

         saveSettingsDebounced();
     });
+    $('#tool_reasoning_mode').on('input', function () {
+        oai_settings.tool_reasoning_mode = getToolReasoningMode({
+            ...oai_settings,
+            tool_reasoning_mode: String($(this).val()),
+        });
+        saveSettingsDebounced();
+    });
     $('#seed_openai').on('input', function () {
         oai_settings.seed = Number($(this).val());
         saveSettingsDebounced();

     $('#openai_show_thoughts').on('input', function () {
         oai_settings.show_thoughts = !!$(this).prop('checked');
+        setToolReasoningControls();
         saveSettingsDebounced();
     });

public/scripts/reasoning.js+3 -1 Viewed

                 case chat_completion_sources.XAI:
                     return data?.choices?.[0]?.message?.reasoning_content ?? '';
                 case chat_completion_sources.OPENROUTER:
-                    return data?.choices?.[0]?.message?.reasoning ?? '';
+                    return data?.choices?.[0]?.message?.reasoning
+                        ?? data?.choices?.[0]?.message?.reasoning_content
+                        ?? '';
                 case chat_completion_sources.MAKERSUITE:
                 case chat_completion_sources.VERTEXAI:
                     return data?.responseContent?.parts?.filter(part => part.thought)?.map(part => part.text)?.join('\n\n') ?? '';

public/scripts/tool-calling.js+3 -1 Viewed

  * @property {string} parameters - The parameters for the tool invocation.
  * @property {string} result - The result of the tool invocation.
  * @property {string?} signature - The thought signature associated with the tool invocation.
+ * @property {string?} reasoning - The plaintext reasoning associated with this tool call turn.
  */
 /**

      * @param {any} data Reply data
      * @returns {Promise<ToolInvocationResult>} Successful tool invocations
      */
-    static async invokeFunctionTools(data) {
+    static async invokeFunctionTools(data, { reasoningText = null } = {}) {
         /** @type {ToolInvocationResult} */
         const result = {
             invocations: [],

                 parameters: stringify(parameters),
                 result: toolResult,
                 signature: toolCall.signature || null,
+                reasoning: reasoningText || null,
             };
             result.invocations.push(invocation);
+        }