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 { 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?: anyToolInvocation[];
         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, 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	5290	else {
5281	5291	// Without streaming we'll be having a full message on continuation. Treat it as a last chunk.
5282	5292	if (originalType !== 'continue') {
5283	5293	({ type, getMessage } = await saveReply({ type, getMessage, title, swipes, reasoning, imageUrls, reasoningSignature }));
5284	5294	}
5285	5295	else {
5286	5296	({ type, getMessage } = await saveReply({ type: 'appendFinal', getMessage, title, swipes, reasoning, imageUrls, reasoningSignature }));
5287	5297	}
5288	5298
5289	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 = [], 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, 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 {objectChatMessage[]} 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?.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, 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: [], 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	2822	text += getStreamingReply(parsed, state);
2796	2823	}
2797	2824
2798	2825	ToolManager.parseToolCalls(toolCalls, parsed, state.toolSignatures);
2799	2826
2800	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, 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, 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, toolSignatures = {}) {
         if (!this.isToolCallingSupported()) {
             return;
+        }

@@ -457,6 +459,11 @@ export class ToolManager {
457	459	const targetToolCall = toolCalls[choiceIndex][toolCallIndex];
458	460
459	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	544	toolCalls[choiceIndex][toolCallIndex] = {};
538	545	}
539	546	const targetToolCall = toolCalls[choiceIndex][toolCallIndex];
	547	+ if (part.thoughtSignature) {
	548	+ targetToolCall.thoughtSignature = part.thoughtSignature;
	549	+ }
540	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, 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	701	if (isGoogleToolCall(data[0])) {
692	702	return data[0].filter(x => x).map((c) => convertGoogleToolCall(c, c.thoughtSignature));
693	703	}
694	704
695	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, 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	646	return response.send({ error: { message } });
646	647	}
647	648
648	649	// Wrap it back to OAI format (responseContent includes thought signatures in parts array)
649	650	const reply = { choices: [{ 'message': { 'content': responseText } }], responseContent };
650	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+79 -7 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') {
                 parts.filter(p =>                        if (typeof ppart.text === 'string' || ppart.inlineData).forEach(p => {
                     p                            part.thoughtSignature = skipSignatureMagic;
 -                });
+                        }
+                    }
 +                }
 +                // Gemini 2.5 without stored signatures: signatures are optional, no bypass needed
 +            });
 +        }
         // merge consecutive messages with the same role
         if (index > 0 && message.role === contents[contents.length - 1].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;
 +        }
 +    }
 +}