Implement Gemini thought signatures (#4886) * Implement Gemini thought signatures * Implement streaming support for Gemini thought signatures * Implement OR support for Gemini thought signatures * Remove unnecessary extraction of thought sigs from response parts * Update thought sig comments to remove explicit Gemini mention * Fix thought_signature naming convention in message.extra * Add thought_signatures to ReasoningMessageExtra typedef * Prevent thought sigs being sent to incompatible endpoints * Move signatures to populateChatHistory, update for consistent casing * Code clean-up * Only send thought signatures if target model and API match original * Implement content-hash thought signature mapping * Change the data model + split for text/functions * Don't include signature to invocations if the model doesn't match * Fix function description * Remove misleading comment * Handle OpenRouter signatures * Improve message extra types * Prevent modifying original invocations when removing signatures * Fix return of openrouter non-streaming signatures * Remove redundant array check --------- Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

2cd2bd4a4de3af6b6df4b0e5e0981a6e1d66c54c

mightytribble <246552901+mightytribble@users.noreply.github.com>

Signed

Parents: 5accfbc5d8566eae5aaeaa8b9f833d518e9893d0

public/global.d.ts+8 -2 Viewed

 import { textgenerationwebui_settings } from './scripts/textgen-settings';
 import { FileAttachment } from './scripts/chats';
 import { ReasoningMessageExtra } from './scripts/reasoning';
-import { OVERSWIPE_BEHAVIOR } from './scripts/constants';
+import { IGNORE_SYMBOL, OVERSWIPE_BEHAVIOR } from './scripts/constants';
+import { ToolInvocation } from './scripts/tool-calling';
 declare global {
     // Custom types

+    }
     interface BaseMessageExtra {
+        api?: string;
+        model?: string;
+        type?: string;
         gen_id?: number;
         bias?: string;
         uses_system_ui?: boolean;
         memory?: string;
         display_text?: string;
         reasoning_display_text?: string;
-        tool_invocations?: any[];
+        tool_invocations?: ToolInvocation[];
         title?: string;
         isSmallSys?: boolean;
         token_count?: number;

         generationType?: number;
         /** @deprecated Use `MediaAttachment.negative` instead */
         negative?: string;
+        /** Will exclude this message from prompt processing */
+        [IGNORE_SYMBOL]?: boolean;
+    }
     type MediaAttachment = MediaAttachmentProps & ImageGenerationAttachmentProps & ImageCaptionAttachmentProps;

public/script.js+20 -5 Viewed

 import { initSettingsSearch } from './scripts/setting-search.js';
 import { initBulkEdit } from './scripts/bulk-edit.js';
 import { getContext } from './scripts/st-context.js';
-import { extractReasoningFromData, initReasoning, parseReasoningInSwipes, PromptReasoning, ReasoningHandler, removeReasoningFromString, updateReasoningUI } from './scripts/reasoning.js';
+import { extractReasoningFromData, extractReasoningSignatureFromData, initReasoning, parseReasoningInSwipes, PromptReasoning, ReasoningHandler, removeReasoningFromString, updateReasoningUI } from './scripts/reasoning.js';
 import { accountStorage } from './scripts/util/AccountStorage.js';
 import { initWelcomeScreen, openPermanentAssistantChat, openPermanentAssistantCard, getPermanentAssistantAvatar } from './scripts/welcome-screen.js';
 import { initDataMaid } from './scripts/data-maid.js';

         this.promptReasoning = promptReasoning;
         /** @type {string[]} */
         this.images = [];
+        /** @type {string?} */
+        this.reasoningSignature = null;
+    }
     /**

             appendMediaToMessage(message, $(this.messageDom));
+        }
+        // Store reasoning signature for models that support multi-turn context
+        if (this.reasoningSignature) {
+            message.extra = message.extra || {};
+            message.extra.reasoning_signature = this.reasoningSignature;
+        }
         this.markUIGenStopped();
         if (this.type !== 'impersonate') {

                 // Get the updated reasoning string into the handler
                 this.reasoningHandler.updateReasoning(this.messageId, state?.reasoning);
                 this.images = state?.images ?? [];
+                this.reasoningSignature = state?.signature ?? null;
                 await eventSource.emit(event_types.STREAM_TOKEN_RECEIVED, text);
                 await sw.tick(async () => await this.onProgressStreaming(this.messageId, this.continueMessage + text));
+            }

         let title = extractTitleFromData(data);
         let reasoning = extractReasoningFromData(data);
         let imageUrls = extractImagesFromData(data);
+        const reasoningSignature = extractReasoningSignatureFromData(data);
         kobold_horde_model = title;
         const swipes = extractMultiSwipes(data, type);

@@ -5280,10 +5290,10 @@ export async function Generate(type, { automatic_trigger, force_name2, quiet_pro
5280	else {	5290	else {
5281	// Without streaming we'll be having a full message on continuation. Treat it as a last chunk.	5291	// Without streaming we'll be having a full message on continuation. Treat it as a last chunk.
5282	if (originalType !== 'continue') {	5292	if (originalType !== 'continue') {
5283	({ type, getMessage } = await saveReply({ type, getMessage, title, swipes, reasoning, imageUrls }));	5293	({ type, getMessage } = await saveReply({ type, getMessage, title, swipes, reasoning, imageUrls, reasoningSignature }));
5284	}	5294	}
5285	else {	5295	else {
5286	({ type, getMessage } = await saveReply({ type: 'appendFinal', getMessage, title, swipes, reasoning, imageUrls }));	5296	({ type, getMessage } = await saveReply({ type: 'appendFinal', getMessage, title, swipes, reasoning, imageUrls, reasoningSignature }));
5287	}	5297	}
5288		5298
5289	// This relies on `saveReply` having been called to add the message to the chat, so it must be last.	5299	// This relies on `saveReply` having been called to add the message to the chat, so it must be last.

  * @property {string[]} [swipes] Extra swipes
  * @property {string} [reasoning] Message reasoning
  * @property {string[]} [imageUrls] Links to images
+ * @property {string?} [reasoningSignature] Encrypted signature of the reasoning text
+ *
  * @typedef {object} SaveReplyResult
  * @property {string} type Type of generation
  * @property {string} getMessage Generated message
  */
-export async function saveReply({ type, getMessage, fromStreaming = false, title = '', swipes = [], reasoning = '', imageUrls = [] }) {
+export async function saveReply({ type, getMessage, fromStreaming = false, title = '', swipes = [], reasoning = '', imageUrls = [], reasoningSignature = null }) {
     // Backward compatibility
     if (arguments.length > 1 && typeof arguments[0] !== 'object') {
         console.trace('saveReply called with positional arguments. Please use an object instead.');
-        [type, getMessage, fromStreaming, title, swipes, reasoning, imageUrls] = arguments;
+        [type, getMessage, fromStreaming, title, swipes, reasoning, imageUrls, reasoningSignature] = arguments;
+    }
     if (type != 'append' && type != 'continue' && type != 'appendFinal' && chat.length && (chat[chat.length - 1]['swipe_id'] === undefined ||

             chat[chat.length - 1]['extra']['model'] = getGeneratingModel();
             chat[chat.length - 1]['extra']['reasoning'] = reasoning;
             chat[chat.length - 1]['extra']['reasoning_duration'] = null;
+            chat[chat.length - 1]['extra']['reasoning_signature'] = reasoningSignature;
             await processImageAttachment(chat[chat.length - 1], { imageUrls });
             if (power_user.message_token_count_enabled) {
                 const tokenCountText = (reasoning || '') + chat[chat.length - 1]['mes'];

         chat[chat.length - 1]['extra']['model'] = getGeneratingModel();
         chat[chat.length - 1]['extra']['reasoning'] = reasoning;
         chat[chat.length - 1]['extra']['reasoning_duration'] = null;
+        chat[chat.length - 1]['extra']['reasoning_signature'] = reasoningSignature;
         await processImageAttachment(chat[chat.length - 1], { imageUrls });
         if (power_user.message_token_count_enabled) {
             const tokenCountText = (reasoning || '') + chat[chat.length - 1]['mes'];

         chat[chat.length - 1]['extra']['api'] = getGeneratingApi();
         chat[chat.length - 1]['extra']['model'] = getGeneratingModel();
         chat[chat.length - 1]['extra']['reasoning'] += reasoning;
+        chat[chat.length - 1]['extra']['reasoning_signature'] = reasoningSignature;
         await processImageAttachment(chat[chat.length - 1], { imageUrls });
         // We don't know if the reasoning duration extended, so we don't update it here on purpose.
         if (power_user.message_token_count_enabled) {

         chat[chat.length - 1]['extra']['model'] = getGeneratingModel();
         chat[chat.length - 1]['extra']['reasoning'] = reasoning;
         chat[chat.length - 1]['extra']['reasoning_duration'] = null;
+        chat[chat.length - 1]['extra']['reasoning_signature'] = reasoningSignature;
         if (power_user.trim_spaces) {
             getMessage = getMessage.trim();
+        }

public/scripts/openai.js+71 -7 Viewed

 /**
  * Formats chat messages into chat completion messages.
- * @param {object[]} chat - Array containing all messages.
+ * @param {ChatMessage[]} chat - Array containing all messages.
  * @returns {object[]} - Array containing all messages formatted for chat completion.
  */
 function setOpenAIMessages(chat) {
     let j = 0;
     // clean openai msgs
     const messages = [];
+    // Get current API and model for thought signature validation
+    const currentApi = oai_settings.chat_completion_source;
+    const currentModel = getChatCompletionModel();
     for (let i = chat.length - 1; i >= 0; i--) {
         let role = chat[j]['is_user'] ? 'user' : 'assistant';
         let content = chat[j]['mes'];

         const media = chat[j]?.extra?.media;
         const mediaDisplay = getMediaDisplay(chat[j]);
         const mediaIndex = getMediaIndex(chat[j]);
-        const invocations = chat[j]?.extra?.tool_invocations;
+        const invocations = chat[j]?.extra?.tool_invocations?.slice();
-        messages[i] = { 'role': role, 'content': content, name: name, 'media': media, 'mediaDisplay': mediaDisplay, 'mediaIndex': mediaIndex, 'invocations': invocations };
+        // Only send thought signatures if they were generated by the same API and model
+        const originApi = chat[j]?.extra?.api;
+        const originModel = chat[j]?.extra?.model;
+        const isSameModel = originApi === currentApi && originModel === currentModel;
+        const signature = isSameModel ? chat[j]?.extra?.reasoning_signature : null;
+        // Remove signatures from invocations if the API/model don't match
+        if (Array.isArray(invocations) && invocations.length > 0) {
+            invocations.forEach((invocation, index) => {
+                if (invocation.signature && !isSameModel) {
+                    const cloneInvocation = structuredClone(invocation);
+                    delete cloneInvocation.signature;
+                    invocations[index] = cloneInvocation;
+                }
+            });
+        }
+        messages[i] = { 'role': role, 'content': content, name: name, 'media': media, 'mediaDisplay': mediaDisplay, 'mediaIndex': mediaIndex, 'invocations': invocations, 'signature': signature };
         j++;
+    }

     const videoInlining = isVideoInliningSupported();
     const audioInlining = isAudioInliningSupported();
     const canUseTools = ToolManager.isToolCallingSupported();
+    const includeSignature = isReasoningSignatureSupported();
     // Insert chat messages as long as there is budget available
     const chatPool = [...messages].reverse();

             const invocations = chatPrompt.invocations;
             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);
+            await toolCallMessage.setToolCalls(invocations, includeSignature);
             if (chatCompletion.canAffordAll([toolCallMessage, ...toolResultMessages])) {
                 for (const resultMessage of toolResultMessages) {
                     chatCompletion.insertAtStart(resultMessage, 'chatHistory');

             continue;
+        }
+        if (includeSignature && chatPrompt.signature) {
+            chatMessage.signature = chatPrompt.signature;
+        }
         if (chatCompletion.canAfford(chatMessage)) {
             chatCompletion.insertAtStart(chatMessage, 'chatHistory');
         } else {

             let text = '';
             const swipes = [];
             const toolCalls = [];
-            const state = { reasoning: '', images: [] };
+            const state = { reasoning: '', images: [], signature: '', toolSignatures: {} };
             while (true) {
                 const { done, value } = await reader.read();
                 if (done) return;

@@ -2795,7 +2822,7 @@ async function sendOpenAIRequest(type, messages, signal, { jsonSchema = null } =
2795	text += getStreamingReply(parsed, state);	2822	text += getStreamingReply(parsed, state);
2796	}	2823	}
2797		2824
2798	ToolManager.parseToolCalls(toolCalls, parsed);	2825	ToolManager.parseToolCalls(toolCalls, parsed, state.toolSignatures);
2799		2826
2800	yield { text, swipes: swipes, logprobs: parseChatCompletionLogprobs(parsed), toolCalls: toolCalls, state: state };	2827	yield { text, swipes: swipes, logprobs: parseChatCompletionLogprobs(parsed), toolCalls: toolCalls, state: state };
2801	}	2828	}

         if (show_thoughts) {
             state.reasoning += (data?.candidates?.[0]?.content?.parts?.filter(x => x.thought)?.map(x => x.text)?.[0] || '');
+        }
+        // Extract thought signatures from streaming chunks (typically in final chunk)
+        const parts = data?.candidates?.[0]?.content?.parts || [];
+        parts.forEach((part) => {
+            if (part.thoughtSignature && typeof part.text === 'string') {
+                state.signature = part.thoughtSignature;
+            }
+        });
         return data?.candidates?.[0]?.content?.parts?.filter(x => !x.thought)?.map(x => x.text)?.[0] || '';
     } else if (chat_completion_source === chat_completion_sources.COHERE) {
         return data?.delta?.message?.content?.text || data?.delta?.message?.tool_plan || '';

         if (show_thoughts) {
             state.reasoning += (data.choices?.filter(x => x?.delta?.reasoning)?.[0]?.delta?.reasoning || '');
+        }
+        // Extract thought signatures from OpenRouter streaming (reasoning_details in delta)
+        const reasoningDetails = data?.choices?.[0]?.delta?.reasoning_details || [];
+        reasoningDetails.forEach((detail) => {
+            if (detail.type === 'reasoning.encrypted' && detail.data) {
+                if (/^tool_/.test(detail.id)) {
+                    state.toolSignatures[detail.id] = detail.data;
+                } else {
+                    state.signature = detail.data;
+                }
+            }
+        });
         return data.choices?.[0]?.delta?.content ?? data.choices?.[0]?.message?.content ?? data.choices?.[0]?.text ?? '';
     } else if ([chat_completion_sources.CUSTOM, chat_completion_sources.POLLINATIONS, chat_completion_sources.AIMLAPI, chat_completion_sources.MOONSHOT, chat_completion_sources.COMETAPI, chat_completion_sources.ELECTRONHUB, chat_completion_sources.NANOGPT, chat_completion_sources.ZAI, chat_completion_sources.SILICONFLOW, chat_completion_sources.CHUTES].includes(chat_completion_source)) {
         if (show_thoughts) {

     name;
     /** @type {object} */
     tool_call = null;
+    /** @type {string?} */
+    signature = 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.
      * @returns {Promise<void>}
      */
-    async setToolCalls(invocations) {
+    async setToolCalls(invocations, includeSignature) {
         this.tool_calls = invocations.map(i => ({
             id: i.id,
             type: 'function',

                 arguments: i.parameters,
                 name: i.name,
             },
+            ...(includeSignature && i.signature ? { signature: i.signature } : {}),
         }));
         this.tokens = await tokenHandler.countAsync({ role: this.role, tool_calls: JSON.stringify(this.tool_calls) });
+    }

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

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

+}
 /**
+ * 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
+ */
+export function isReasoningSignatureSupported(settings = oai_settings) {
+    // If it's Vertex AI or Makersuite, that's OK - convertGooglePrompt() will handle it later
+    const isGoogle = [chat_completion_sources.VERTEXAI, chat_completion_sources.MAKERSUITE].includes(settings.chat_completion_source);
+    // Need a more crunchy check for OpenRouter: look for Gemini models
+    const isOpenRouterGemini = settings.chat_completion_source === chat_completion_sources.OPENROUTER && /google\/gemini/i.test(settings.openrouter_model);
+    return isGoogle || isOpenRouterGemini;
+}
+/**
  * Proxy stuff
  */
 export function loadProxyPresets(settings) {

public/scripts/reasoning.js+48 -0 Viewed

+}
 /**
+ * Extracts encrypted reasoning signature from the response data.
+ * These signatures are used to maintain reasoning context across multi-turn conversations.
+ * @param {object} data Response data
+ * @param {object} [options] Optional parameters
+ * @param {string|null} [options.mainApi] Override for main API
+ * @param {string|null} [options.chatCompletionSource] Override for chat completion source
+ * @returns {string?} Encrypted signature of the reasoning text
+ */
+export function extractReasoningSignatureFromData(data, {
+    mainApi = null,
+    chatCompletionSource = null,
+} = {}) {
+    // Only Gemini models use thought signatures (via MakerSuite/VertexAI or OpenRouter)
+    if ((mainApi ?? main_api) !== 'openai') {
+        return null;
+    }
+    const source = chatCompletionSource ?? oai_settings.chat_completion_source;
+    const isGemini = source === chat_completion_sources.MAKERSUITE || source === chat_completion_sources.VERTEXAI;
+    const isOpenRouter = source === chat_completion_sources.OPENROUTER;
+    if (!isGemini && !isOpenRouter) {
+        return null;
+    }
+    // OpenRouter format: reasoning_details array with type "reasoning.encrypted" (exclude tool calls)
+    if (isOpenRouter && Array.isArray(data?.choices?.[0]?.message?.reasoning_details)) {
+        for (const detail of data.choices[0].message.reasoning_details) {
+            if (!/^tool_/.test(detail.id) && detail.type === 'reasoning.encrypted' && detail.data) {
+                return detail.data;
+            }
+        }
+    }
+    // Direct Gemini format: Extract from responseContent.parts if available (only text parts)
+    if (isGemini && Array.isArray(data?.responseContent?.parts)) {
+        data.responseContent.parts.forEach((part) => {
+            if (part.thoughtSignature && typeof part.text === 'string') {
+                return part.thoughtSignature;
+            }
+        });
+    }
+    return null;
+}
+/**
  * Check if the model supports reasoning, but does not send back the reasoning
  * @returns {boolean} True if the model supports reasoning
  */

  * @property {string} reasoning Reasoning block
  * @property {number} reasoning_duration Duration of the reasoning block
  * @property {string} reasoning_type Type of reasoning block
+ * @property {string?} reasoning_signature Encrypted signature of the reasoning text
  */
 export function parseReasoningInSwipes(swipes, swipeInfoArray, duration) {
     if (!power_user.reasoning.auto_parse) {

public/scripts/tool-calling.js+29 -6 Viewed

 import { DOMPurify } from '../lib.js';
-import { addOneMessage, chat, event_types, eventSource, main_api, saveChatConditional, system_avatar, systemUserName } from '../script.js';
+import { addOneMessage, chat, event_types, eventSource, getGeneratingApi, getGeneratingModel, main_api, saveChatConditional, system_avatar, systemUserName } from '../script.js';
 import { chat_completion_sources, custom_prompt_post_processing_types, getChatCompletionModel, model_list, oai_settings } from './openai.js';
 import { Popup } from './popup.js';
 import { SlashCommand } from './slash-commands/SlashCommand.js';

  * @property {string} name - The name of the tool.
  * @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.
  */
 /**

      * Utility function to parse tool calls from a parsed response.
      * @param {any[]} toolCalls The tool calls to update.
      * @param {any} parsed The parsed response from the OpenAI API.
+     * @param {object} toolSignatures Optional mapping of tool call IDs to thought signatures.
      * @returns {void}
      */
-    static parseToolCalls(toolCalls, parsed) {
+    static parseToolCalls(toolCalls, parsed, toolSignatures = {}) {
         if (!this.isToolCallingSupported()) {
             return;
+        }

@@ -457,6 +459,11 @@ export class ToolManager {
457	const targetToolCall = toolCalls[choiceIndex][toolCallIndex];	459	const targetToolCall = toolCalls[choiceIndex][toolCallIndex];
458		460
459	ToolManager.#applyToolCallDelta(targetToolCall, toolCallDelta);	461	ToolManager.#applyToolCallDelta(targetToolCall, toolCallDelta);
		462
		463	// Transfer thought signature if available
		464	if (Object.hasOwn(toolSignatures, targetToolCall.id)) {
		465	targetToolCall.signature = toolSignatures[targetToolCall.id];
		466	}
460	}	467	}
461	}	468	}
462	}	469	}

@@ -537,6 +544,9 @@ export class ToolManager {
537	toolCalls[choiceIndex][toolCallIndex] = {};	544	toolCalls[choiceIndex][toolCallIndex] = {};
538	}	545	}
539	const targetToolCall = toolCalls[choiceIndex][toolCallIndex];	546	const targetToolCall = toolCalls[choiceIndex][toolCallIndex];
		547	if (part.thoughtSignature) {
		548	targetToolCall.thoughtSignature = part.thoughtSignature;
		549	}
540	ToolManager.#applyToolCallDelta(targetToolCall, part.functionCall);	550	ToolManager.#applyToolCallDelta(targetToolCall, part.functionCall);
541	}	551	}
542	}	552	}

         const isClaudeToolCall = c => Array.isArray(c) ? c.filter(x => x).every(isClaudeToolCall) : c?.input && c?.name && c?.id;
         const isGoogleToolCall = c => Array.isArray(c) ? c.filter(x => x).every(isGoogleToolCall) : c?.name && c?.args;
         const convertClaudeToolCall = c => ({ id: c.id, function: { name: c.name, arguments: c.input } });
-        const convertGoogleToolCall = (c) => ({ id: getRandomId(), function: { name: c.name, arguments: c.args } });
+        const convertGoogleToolCall = (c, signature = null) => ({ id: getRandomId(), function: { name: c.name, arguments: c.args }, signature });
         // Parsed tool calls from streaming data
         if (Array.isArray(data) && data.length > 0 && Array.isArray(data[0])) {

@@ -689,7 +699,7 @@ export class ToolManager {
689	}	699	}
690		700
691	if (isGoogleToolCall(data[0])) {	701	if (isGoogleToolCall(data[0])) {
692	return data[0].filter(x => x).map(convertGoogleToolCall);	702	return data[0].filter(x => x).map((c) => convertGoogleToolCall(c, c.thoughtSignature));
693	}	703	}
694		704
695	if (typeof data[0]?.[0]?.tool_calls === 'object') {	705	if (typeof data[0]?.[0]?.tool_calls === 'object') {

         // Google AI Studio tool calls
         if (Array.isArray(data?.responseContent?.parts)) {
-            return data.responseContent.parts.filter(p => p.functionCall).map(p => convertGoogleToolCall(p.functionCall));
+            return data.responseContent.parts.filter(p => p.functionCall).map(p => convertGoogleToolCall(p.functionCall, p.thoughtSignature));
+        }
         // Parsed tool calls from non-streaming data

             // Find a choice with 0-index
             const choice = data.choices.find(choice => choice.index === 0);
-            if (choice) {
+            if (choice && typeof choice.message === 'object' && Array.isArray(choice.message.tool_calls)) {
+                // Add OpenRouter signatures
+                if (Array.isArray(choice.message.reasoning_details)) {
+                    for (const toolCall of choice.message.tool_calls) {
+                        const reasoningDetail = choice.message.reasoning_details.find(rd => rd.id === toolCall.id);
+                        if (reasoningDetail && reasoningDetail.type === 'reasoning.encrypted' && reasoningDetail.data) {
+                            toolCall.signature = reasoningDetail.data;
+                        }
+                    }
+                }
                 return choice.message.tool_calls;
+            }
+        }

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

             extra: {
                 isSmallSys: true,
                 tool_invocations: invocations,
+                api: getGeneratingApi(),
+                model: getGeneratingModel(),
             },
         };
         chat.push(message);

src/endpoints/backends/chat-completions.js+3 -1 Viewed

     embedOpenRouterMedia,
     addReasoningContentToToolCalls,
     cachingSystemPromptForOpenRouterClaude,
+    addOpenRouterSignatures,
 } from '../../prompt-converters.js';
 import { readSecret, SECRET_KEYS } from '../secrets.js';

@@ -645,7 +646,7 @@ async function sendMakerSuiteRequest(request, response) {
645	return response.send({ error: { message } });	646	return response.send({ error: { message } });
646	}	647	}
647		648
648	// Wrap it back to OAI format	649	// Wrap it back to OAI format (responseContent includes thought signatures in parts array)
649	const reply = { choices: [{ 'message': { 'content': responseText } }], responseContent };	650	const reply = { choices: [{ 'message': { 'content': responseText } }], responseContent };
650	return response.send(reply);	651	return response.send(reply);
651	}	652	}

             const cacheTTL = getConfigValue('claude.extendedTTL', false, 'boolean') ? '1h' : '5m';
             if (Array.isArray(request.body.messages)) {
                 embedOpenRouterMedia(request.body.messages);
+                addOpenRouterSignatures(request.body.messages, request.body.model);
                 if (isClaude3or4) {
                     if (enableSystemPromptCache) {

src/prompt-converters.js+80 -8 Viewed

                             name: toolCall.function.name,
                             args: tryParse(toolCall.function.arguments) ?? toolCall.function.arguments,
                         },
+                        ...(toolCall.signature ? { thoughtSignature: toolCall.signature } : {}),
                     });
                     toolNameMap[toolCall.id] = toolCall.function.name;

         });
         // https://ai.google.dev/gemini-api/docs/gemini-3#migrating_from_other_models
-        if (/gemini-3/.test(model)) {
+        // Inject stored thought signatures, or fall back to bypass magic for Gemini 3
+        if (/gemini-3/.test(model) || /gemini-2\.5/.test(model)) {
             const skipSignatureMagic = 'skip_thought_signature_validator';
-            parts.filter(p => p.functionCall).forEach(p => {
+            const textSignature = message.signature;
-                p.thoughtSignature = skipSignatureMagic;
+            parts.forEach((part) => {
+                if (textSignature && typeof part.text === 'string') {
+                    part.thoughtSignature = textSignature;
+                } else if (/gemini-3/.test(model)) {
+                    // Gemini 3: Fall back to bypass magic for function calls (mandatory) and images
+                    if (part.functionCall && !part.thoughtSignature) {
+                        part.thoughtSignature = skipSignatureMagic;
+                    }
+                    if (/-image/.test(model) && message.role === 'model') {
+                        if (typeof part.text === 'string' || part.inlineData) {
+                            part.thoughtSignature = skipSignatureMagic;
+                        }
+                    }
+                }
+                // Gemini 2.5 without stored signatures: signatures are optional, no bypass needed
             });
-            if (/-image/.test(model) && message.role === 'model') {
-                parts.filter(p => typeof p.text === 'string' || p.inlineData).forEach(p => {
-                    p.thoughtSignature = skipSignatureMagic;
-                });
-            }
+        }
         // merge consecutive messages with the same role

         message.reasoning_content = '';
+    }
+}
+/**
+ * Converts reasoning signatures to OpenRouter format.
+ * @param {object[]} messages Array of messages
+ * @param {string} model Model name
+ * @return {void}
+ */
+export function addOpenRouterSignatures(messages, model) {
+    const getFormatForModel = () => {
+        if (/google\/gemini/.test(model)) {
+            return 'google-gemini-v1';
+        }
+        if (/anthropic\/claude/.test(model)) {
+            return 'anthropic-claude-v1';
+        }
+        if (/openai\/gpt/.test(model)) {
+            return 'openai-responses-v1';
+        }
+        if (/x-ai\/grok/.test(model)) {
+            return 'xai-responses-v1';
+        }
+        return 'unknown';
+    };
+    if (!Array.isArray(messages)) {
+        return;
+    }
+    for (const message of messages) {
+        const details = [];
+        const addDetail = (data, id) => {
+            if (typeof data !== 'string' || data.length === 0) {
+                return;
+            }
+            const detail = {
+                index: details.length,
+                id: id || `signature-${details.length}`,
+                type: 'reasoning.encrypted',
+                data: data,
+                format: getFormatForModel(),
+            };
+            details.push(detail);
+        };
+        if (typeof message.signature === 'string') {
+            addDetail(message.signature);
+            delete message.signature;
+        }
+        if (Array.isArray(message.tool_calls)) {
+            message.tool_calls.forEach((toolCall) => {
+                if (typeof toolCall.signature === 'string') {
+                    addDetail(toolCall.signature, toolCall.id);
+                    delete toolCall.signature;
+                }
+            });
+        }
+        if (details.length > 0) {
+            message.reasoning_details = details;
+        }
+    }
+}