shortcutxl 0.3.92 → 0.4.0

package/dist/ai/providers/anthropic.js

@@ -1,5 +1,6 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { PROVIDER_REFUSAL_ERROR_CODE, safeModelStreamErrorMessage } from '../../contracts/model-stream.js';
+import { isResponseModel } from '../../contracts/refusal-fallback.js';
 import { getEnvApiKey } from '../env-api-keys.js';
 import { assertModelSupportsReasoningLevel, calculateCost } from '../models.js';
 import { AssistantMessageEventStream } from '../utils/event-stream.js';
@@ -153,224 +154,356 @@ export const streamAnthropic = (model, context, options) => {
             stopReason: 'stop',
             timestamp: Date.now()
         };
+        let fallbackAttempted = false;
+        let servingModel = model;
+        let initialFallbackCache;
         try {
             const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? '';
-            const client = createClient(model, apiKey, options?.interleavedThinking ?? true, options?.headers, options?.fetchOptions, options?.fetch);
+            const client = createClient(model, apiKey, options?.interleavedThinking ?? true, options?.resolveRefusalFallbackModel
+                ? mergeHeaders(options.headers, {
+                    'anthropic-beta': 'fallback-credit-2026-07-01',
+                    'X-LLM-Refusal-Fallback': 'enabled'
+                })
+                : options?.headers, options?.fetchOptions, options?.fetch);
             const params = buildParams(model, context, options);
             options?.onPayload?.(params);
             // Consume raw events because this provider owns accumulation. The SDK's
             // MessageStream accumulator assumes usage is always present, but private
             // gateways can omit initial usage from otherwise valid response streams.
-            const anthropicStream = await client.messages.create({ ...params, stream: true }, { signal: options?.signal });
-            stream.push({ type: 'start', partial: output });
-            const blocks = output.content;
-            let uncachedInputTokens = 0;
-            let providerStopReason;
-            for await (const event of anthropicStream) {
-                if (event.type === 'message_start') {
-                    // Capture initial token usage from message_start event
-                    // This ensures we have input token counts even if the stream is aborted early
-                    const usage = event.message.usage;
-                    uncachedInputTokens = usage?.input_tokens ?? 0;
-                    output.usage.output = usage?.output_tokens ?? 0;
-                    output.usage.cacheRead = usage?.cache_read_input_tokens ?? 0;
-                    output.usage.cacheWrite = usage?.cache_creation_input_tokens ?? 0;
-                    // Anthropic doesn't provide total_tokens; usage.input is normalized
-                    // to total input, including cache buckets.
-                    output.usage.input =
-                        uncachedInputTokens + output.usage.cacheRead + output.usage.cacheWrite;
-                    output.usage.totalTokens = output.usage.input + output.usage.output;
-                    calculateCost(model, output.usage);
-                }
-                else if (event.type === 'content_block_start') {
-                    if (event.content_block.type === 'text') {
-                        const block = {
-                            type: 'text',
-                            text: '',
-                            index: event.index
-                        };
-                        output.content.push(block);
-                        stream.push({
-                            type: 'text_start',
-                            contentIndex: output.content.length - 1,
-                            partial: output
-                        });
-                    }
-                    else if (event.content_block.type === 'thinking') {
-                        const block = {
-                            type: 'thinking',
-                            thinking: '',
-                            thinkingSignature: '',
-                            index: event.index
-                        };
-                        output.content.push(block);
-                        stream.push({
-                            type: 'thinking_start',
-                            contentIndex: output.content.length - 1,
-                            partial: output
-                        });
-                    }
-                    else if (event.content_block.type === 'redacted_thinking') {
-                        const block = {
-                            type: 'thinking',
-                            thinking: '[Reasoning redacted]',
-                            thinkingSignature: event.content_block.data,
-                            redacted: true,
-                            index: event.index
-                        };
-                        output.content.push(block);
-                        stream.push({
-                            type: 'thinking_start',
-                            contentIndex: output.content.length - 1,
-                            partial: output
-                        });
-                    }
-                    else if (event.content_block.type === 'tool_use') {
-                        const block = {
-                            type: 'toolCall',
-                            id: event.content_block.id,
-                            name: event.content_block.name,
-                            arguments: event.content_block.input ?? {},
-                            partialJson: '',
-                            index: event.index
-                        };
-                        output.content.push(block);
-                        stream.push({
-                            type: 'toolcall_start',
-                            contentIndex: output.content.length - 1,
-                            partial: output
-                        });
+            let requestParams = { ...params, stream: true };
+            let retryHeaders;
+            for (;;) {
+                const { data: anthropicStream, response } = await client.messages
+                    .create(requestParams, {
+                    signal: options?.signal,
+                    ...(retryHeaders ? { maxRetries: 0 } : {}),
+                    headers: retryHeaders
+                })
+                    .withResponse();
+                const blocks = output.content;
+                let uncachedInputTokens = 0;
+                let providerStopReason;
+                let stopDetails;
+                let unsafeBoundary = false;
+                let completed = false;
+                for await (const event of anthropicStream) {
+                    if (event.type === 'message_stop')
+                        completed = true;
+                    if (event.type === 'message_start') {
+                        output.responseModel = isResponseModel(event.message.model)
+                            ? event.message.model
+                            : undefined;
+                        if (output.refusalFallback) {
+                            output.refusalFallback = {
+                                ...output.refusalFallback,
+                                servingModel: output.responseModel,
+                                phase: 'streaming'
+                            };
+                        }
+                        // Capture initial token usage from message_start event
+                        // This ensures we have input token counts even if the stream is aborted early
+                        const usage = event.message.usage;
+                        uncachedInputTokens = usage?.input_tokens ?? 0;
+                        output.usage.output = usage?.output_tokens ?? 0;
+                        output.usage.cacheRead = usage?.cache_read_input_tokens ?? 0;
+                        output.usage.cacheWrite = usage?.cache_creation_input_tokens ?? 0;
+                        // Anthropic doesn't provide total_tokens; usage.input is normalized
+                        // to total input, including cache buckets.
+                        output.usage.input =
+                            uncachedInputTokens + output.usage.cacheRead + output.usage.cacheWrite;
+                        output.usage.totalTokens = output.usage.input + output.usage.output;
+                        calculateCost(servingModel, output.usage);
+                        if (fallbackAttempted)
+                            initialFallbackCache = {
+                                read: output.usage.cacheRead,
+                                write: output.usage.cacheWrite
+                            };
+                        stream.push({ type: 'start', partial: output });
                     }
-                }
-                else if (event.type === 'content_block_delta') {
-                    if (event.delta.type === 'text_delta') {
-                        const index = blocks.findIndex((b) => b.index === event.index);
-                        const block = blocks[index];
-                        if (block && block.type === 'text') {
-                            block.text += event.delta.text;
+                    else if (event.type === 'content_block_start') {
+                        if (!['text', 'thinking', 'redacted_thinking'].includes(event.content_block.type))
+                            unsafeBoundary = true;
+                        if (event.content_block.type === 'text') {
+                            const block = {
+                                type: 'text',
+                                text: '',
+                                index: event.index
+                            };
+                            output.content.push(block);
                             stream.push({
-                                type: 'text_delta',
-                                contentIndex: index,
-                                delta: event.delta.text,
+                                type: 'text_start',
+                                contentIndex: output.content.length - 1,
                                 partial: output
                             });
                         }
-                    }
-                    else if (event.delta.type === 'thinking_delta') {
-                        const index = blocks.findIndex((b) => b.index === event.index);
-                        const block = blocks[index];
-                        if (block && block.type === 'thinking') {
-                            block.thinking += event.delta.thinking;
+                        else if (event.content_block.type === 'thinking') {
+                            const block = {
+                                type: 'thinking',
+                                thinking: '',
+                                thinkingSignature: '',
+                                index: event.index
+                            };
+                            output.content.push(block);
                             stream.push({
-                                type: 'thinking_delta',
-                                contentIndex: index,
-                                delta: event.delta.thinking,
+                                type: 'thinking_start',
+                                contentIndex: output.content.length - 1,
                                 partial: output
                             });
                         }
-                    }
-                    else if (event.delta.type === 'input_json_delta') {
-                        const index = blocks.findIndex((b) => b.index === event.index);
-                        const block = blocks[index];
-                        if (block && block.type === 'toolCall') {
-                            block.partialJson += event.delta.partial_json;
-                            block.arguments = parseStreamingJson(block.partialJson);
+                        else if (event.content_block.type === 'redacted_thinking') {
+                            const block = {
+                                type: 'thinking',
+                                thinking: '[Reasoning redacted]',
+                                thinkingSignature: event.content_block.data,
+                                redacted: true,
+                                index: event.index
+                            };
+                            output.content.push(block);
                             stream.push({
-                                type: 'toolcall_delta',
-                                contentIndex: index,
-                                delta: event.delta.partial_json,
+                                type: 'thinking_start',
+                                contentIndex: output.content.length - 1,
                                 partial: output
                             });
                         }
+                        else if (event.content_block.type === 'tool_use') {
+                            const block = {
+                                type: 'toolCall',
+                                id: event.content_block.id,
+                                name: event.content_block.name,
+                                arguments: event.content_block.input ?? {},
+                                partialJson: '',
+                                index: event.index
+                            };
+                            output.content.push(block);
+                            stream.push({
+                                type: 'toolcall_start',
+                                contentIndex: output.content.length - 1,
+                                partial: output
+                            });
+                        }
+                    }
+                    else if (event.type === 'content_block_delta') {
+                        if (event.delta.type === 'text_delta') {
+                            const index = blocks.findIndex((b) => b.index === event.index);
+                            const block = blocks[index];
+                            if (block && block.type === 'text') {
+                                block.text += event.delta.text;
+                                stream.push({
+                                    type: 'text_delta',
+                                    contentIndex: index,
+                                    delta: event.delta.text,
+                                    partial: output
+                                });
+                            }
+                        }
+                        else if (event.delta.type === 'thinking_delta') {
+                            const index = blocks.findIndex((b) => b.index === event.index);
+                            const block = blocks[index];
+                            if (block && block.type === 'thinking') {
+                                block.thinking += event.delta.thinking;
+                                stream.push({
+                                    type: 'thinking_delta',
+                                    contentIndex: index,
+                                    delta: event.delta.thinking,
+                                    partial: output
+                                });
+                            }
+                        }
+                        else if (event.delta.type === 'input_json_delta') {
+                            const index = blocks.findIndex((b) => b.index === event.index);
+                            const block = blocks[index];
+                            if (block && block.type === 'toolCall') {
+                                block.partialJson += event.delta.partial_json;
+                                block.arguments = parseStreamingJson(block.partialJson);
+                                stream.push({
+                                    type: 'toolcall_delta',
+                                    contentIndex: index,
+                                    delta: event.delta.partial_json,
+                                    partial: output
+                                });
+                            }
+                        }
+                        else if (event.delta.type === 'signature_delta') {
+                            const index = blocks.findIndex((b) => b.index === event.index);
+                            const block = blocks[index];
+                            if (block && block.type === 'thinking') {
+                                block.thinkingSignature = block.thinkingSignature || '';
+                                block.thinkingSignature += event.delta.signature;
+                            }
+                        }
                     }
-                    else if (event.delta.type === 'signature_delta') {
+                    else if (event.type === 'content_block_stop') {
                         const index = blocks.findIndex((b) => b.index === event.index);
                         const block = blocks[index];
-                        if (block && block.type === 'thinking') {
-                            block.thinkingSignature = block.thinkingSignature || '';
-                            block.thinkingSignature += event.delta.signature;
+                        if (block) {
+                            delete block.index;
+                            if (block.type === 'text') {
+                                stream.push({
+                                    type: 'text_end',
+                                    contentIndex: index,
+                                    content: block.text,
+                                    partial: output
+                                });
+                            }
+                            else if (block.type === 'thinking') {
+                                stream.push({
+                                    type: 'thinking_end',
+                                    contentIndex: index,
+                                    content: block.thinking,
+                                    partial: output
+                                });
+                            }
+                            else if (block.type === 'toolCall') {
+                                block.arguments = parseStreamingJson(block.partialJson);
+                                delete block.partialJson;
+                                stream.push({
+                                    type: 'toolcall_end',
+                                    contentIndex: index,
+                                    toolCall: block,
+                                    partial: output
+                                });
+                            }
                         }
                     }
-                }
-                else if (event.type === 'content_block_stop') {
-                    const index = blocks.findIndex((b) => b.index === event.index);
-                    const block = blocks[index];
-                    if (block) {
-                        delete block.index;
-                        if (block.type === 'text') {
-                            stream.push({
-                                type: 'text_end',
-                                contentIndex: index,
-                                content: block.text,
-                                partial: output
-                            });
+                    else if (event.type === 'message_delta') {
+                        if (event.delta.stop_reason) {
+                            providerStopReason = event.delta.stop_reason;
+                            const details = event.delta.stop_details;
+                            if (details && typeof details === 'object' && !Array.isArray(details))
+                                stopDetails = details;
+                            output.stopReason = mapStopReason(event.delta.stop_reason);
                         }
-                        else if (block.type === 'thinking') {
-                            stream.push({
-                                type: 'thinking_end',
-                                contentIndex: index,
-                                content: block.thinking,
-                                partial: output
-                            });
+                        // Only update usage fields if present (not null).
+                        // Preserves input_tokens from message_start when proxies omit it in message_delta.
+                        const usage = event.usage;
+                        if (usage?.output_tokens != null) {
+                            output.usage.output = usage.output_tokens;
                         }
-                        else if (block.type === 'toolCall') {
-                            block.arguments = parseStreamingJson(block.partialJson);
-                            delete block.partialJson;
-                            stream.push({
-                                type: 'toolcall_end',
-                                contentIndex: index,
-                                toolCall: block,
-                                partial: output
-                            });
+                        if (usage?.cache_read_input_tokens != null) {
+                            output.usage.cacheRead = usage.cache_read_input_tokens;
+                        }
+                        if (usage?.cache_creation_input_tokens != null) {
+                            output.usage.cacheWrite = usage.cache_creation_input_tokens;
                         }
+                        if (usage?.input_tokens != null) {
+                            uncachedInputTokens = usage.input_tokens;
+                        }
+                        // Anthropic doesn't provide total_tokens; usage.input is normalized
+                        // to total input, including cache buckets.
+                        output.usage.input =
+                            uncachedInputTokens + output.usage.cacheRead + output.usage.cacheWrite;
+                        output.usage.totalTokens = output.usage.input + output.usage.output;
+                        calculateCost(servingModel, output.usage);
                     }
                 }
-                else if (event.type === 'message_delta') {
-                    if (event.delta.stop_reason) {
-                        providerStopReason = event.delta.stop_reason;
-                        output.stopReason = mapStopReason(event.delta.stop_reason);
-                    }
-                    // Only update usage fields if present (not null).
-                    // Preserves input_tokens from message_start when proxies omit it in message_delta.
-                    const usage = event.usage;
-                    if (usage?.output_tokens != null) {
-                        output.usage.output = usage.output_tokens;
-                    }
-                    if (usage?.cache_read_input_tokens != null) {
-                        output.usage.cacheRead = usage.cache_read_input_tokens;
-                    }
-                    if (usage?.cache_creation_input_tokens != null) {
-                        output.usage.cacheWrite = usage.cache_creation_input_tokens;
+                if (options?.signal?.aborted) {
+                    throw new Error('Request was aborted');
+                }
+                if (!completed) {
+                    throw new AnthropicTerminalStopError({ providerErrorType: 'network', retryable: false });
+                }
+                if (completed &&
+                    providerStopReason === 'refusal' &&
+                    !fallbackAttempted &&
+                    !unsafeBoundary &&
+                    ['cyber', 'bio', 'frontier_llm'].includes(String(stopDetails?.category)) &&
+                    !('fallbacks' in params) &&
+                    !('fallback_credit_token' in params)) {
+                    const targetId = response.headers.get('X-LLM-Refusal-Fallback-Model');
+                    const target = targetId ? options?.resolveRefusalFallbackModel?.(targetId) : undefined;
+                    if (target &&
+                        target.id !== model.id &&
+                        target.api === model.api &&
+                        target.baseUrl === model.baseUrl) {
+                        const token = stopDetails?.fallback_credit_token;
+                        const credit = typeof token === 'string' && token.length > 0;
+                        // No tool block has appeared, so replaying this single uncommitted
+                        // request is safe. The unchanged-body credit shape avoids mixing
+                        // partial thinking from two models and is accepted without prefill.
+                        requestParams = {
+                            ...params,
+                            model: target.id,
+                            ...(credit ? { fallback_credit_token: token } : {})
+                        };
+                        retryHeaders = {
+                            'X-LLM-Refusal-Fallback': response.headers.get('X-LLM-Provider-Model') ?? model.id,
+                            'X-LLM-Refusal-Source-Id': response.headers.get('X-LLM-Refusal-Source-Id') ?? '',
+                            'X-LLM-Refusal-Category': String(stopDetails?.category),
+                            'X-LLM-Refusal-Credit': credit ? 'submitted' : 'unavailable',
+                            'X-Request-Id': crypto.randomUUID()
+                        };
+                        output.refusalFallback = {
+                            requestedModel: model.id,
+                            targetModel: target.id,
+                            scope: 'response',
+                            phase: 'attempting',
+                            credit: credit ? 'pending' : 'unavailable'
+                        };
+                        output.responseModel = undefined;
+                        fallbackAttempted = true;
+                        servingModel = target;
+                        output.model = target.id;
+                        output.content = [];
+                        output.stopReason = 'stop';
+                        output.usage = {
+                            input: 0,
+                            output: 0,
+                            cacheRead: 0,
+                            cacheWrite: 0,
+                            totalTokens: 0,
+                            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+                        };
+                        stream.push({ type: 'start', partial: output });
+                        continue;
                     }
-                    if (usage?.input_tokens != null) {
-                        uncachedInputTokens = usage.input_tokens;
+                }
+                if (output.stopReason === 'aborted' || output.stopReason === 'error') {
+                    const details = anthropicTerminalStopErrorDetails(providerStopReason);
+                    if (details) {
+                        throw new AnthropicTerminalStopError(details);
                     }
-                    // Anthropic doesn't provide total_tokens; usage.input is normalized
-                    // to total input, including cache buckets.
-                    output.usage.input =
-                        uncachedInputTokens + output.usage.cacheRead + output.usage.cacheWrite;
-                    output.usage.totalTokens = output.usage.input + output.usage.output;
-                    calculateCost(model, output.usage);
+                    throw new Error('An unknown error occurred');
                 }
-            }
-            if (options?.signal?.aborted) {
-                throw new Error('Request was aborted');
-            }
-            if (output.stopReason === 'aborted' || output.stopReason === 'error') {
-                const details = anthropicTerminalStopErrorDetails(providerStopReason);
-                if (details) {
-                    throw new AnthropicTerminalStopError(details);
+                if (output.refusalFallback) {
+                    // Submission alone is not proof of an offset (already-warm caches can
+                    // have no repricing). Only confirm an observed matching bucket shift.
+                    const shift = initialFallbackCache
+                        ? initialFallbackCache.write - output.usage.cacheWrite
+                        : 0;
+                    const applied = initialFallbackCache !== undefined &&
+                        shift > 0 &&
+                        output.usage.cacheRead - initialFallbackCache.read === shift;
+                    output.refusalFallback = {
+                        ...output.refusalFallback,
+                        phase: 'completed',
+                        credit: output.refusalFallback.credit === 'pending'
+                            ? applied
+                                ? 'applied'
+                                : 'unconfirmed'
+                            : output.refusalFallback.credit
+                    };
                 }
-                throw new Error('An unknown error occurred');
+                stream.push({ type: 'done', reason: output.stopReason, message: output });
+                stream.end();
+                break;
             }
-            stream.push({ type: 'done', reason: output.stopReason, message: output });
-            stream.end();
         }
         catch (error) {
             for (const block of output.content)
                 delete block.index;
             output.stopReason = options?.signal?.aborted ? 'aborted' : 'error';
-            applyNormalizedProviderError(output, error);
+            if (output.refusalFallback) {
+                output.refusalFallback = {
+                    ...output.refusalFallback,
+                    phase: options?.signal?.aborted ? 'cancelled' : 'failed',
+                    credit: output.refusalFallback.credit === 'pending'
+                        ? 'unconfirmed'
+                        : output.refusalFallback.credit
+                };
+            }
+            applyNormalizedProviderError(output, fallbackAttempted && !options?.signal?.aborted
+                ? new AnthropicTerminalStopError({ code: PROVIDER_REFUSAL_ERROR_CODE, retryable: false })
+                : error);
             stream.push({ type: 'error', reason: output.stopReason, error: output });
             stream.end();
         }

package/dist/ai/providers/google-shared.d.ts

@@ -2,12 +2,14 @@
  * Shared utilities for Google Generative AI and Google Cloud Code Assist providers.
  */
 import { type Content, FinishReason, FunctionCallingConfigMode, type Part } from '@google/genai';
-import type { Context, Model, StopReason, Tool } from '../types.js';
+import type { Context, EnabledReasoningLevel, Model, StopReason, Tool } from '../types.js';
 type GoogleApiType = 'google-generative-ai' | 'google-vertex';
 /**
  * Mirrors Google's ThinkingLevel enum values.
  */
 export type GoogleThinkingLevel = 'THINKING_LEVEL_UNSPECIFIED' | 'MINIMAL' | 'LOW' | 'MEDIUM' | 'HIGH';
+/** Serialize a declared thinking-level capability independently of model version. */
+export declare function getGoogleThinkingLevel(effort: EnabledReasoningLevel): GoogleThinkingLevel;
 /**
  * Determines whether a streamed Gemini `Part` should be treated as "thinking".
  *

package/dist/ai/providers/google-shared.js

@@ -4,6 +4,22 @@
 import { FinishReason, FunctionCallingConfigMode } from '@google/genai';
 import { sanitizeSurrogates } from '../utils/sanitize-unicode.js';
 import { transformMessages } from './transform-messages.js';
+/** Serialize a declared thinking-level capability independently of model version. */
+export function getGoogleThinkingLevel(effort) {
+    switch (effort) {
+        case 'minimal':
+            return 'MINIMAL';
+        case 'low':
+            return 'LOW';
+        case 'medium':
+            return 'MEDIUM';
+        case 'high':
+            return 'HIGH';
+        case 'xhigh':
+        case 'max':
+            throw new Error(`Google thinking levels do not support reasoning level "${effort}".`);
+    }
+}
 /**
  * Determines whether a streamed Gemini `Part` should be treated as "thinking".
  *
@@ -110,26 +126,27 @@ export function convertMessages(model, context) {
         else if (msg.role === 'assistant') {
             const parts = [];
             // Check if message is from same provider and model - only then keep thinking blocks
-            const isSameProviderAndModel = msg.provider === model.provider && msg.model === model.id;
+            const isSameProviderAndModel = msg.provider === model.provider && msg.api === model.api && msg.model === model.id;
+            const firstToolCall = msg.content.find((block) => block.type === 'toolCall');
+            const hasSignedToolCalls = Boolean(resolveThoughtSignature(isSameProviderAndModel, firstToolCall?.thoughtSignature));
             for (const block of msg.content) {
                 if (block.type === 'text') {
-                    // Skip empty text blocks - they can cause issues with some models.
-                    if (!block.text || block.text.trim() === '')
-                        continue;
                     const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.textSignature);
+                    // Empty signed parts still carry provider replay state.
+                    if (!thoughtSignature && (!block.text || block.text.trim() === ''))
+                        continue;
                     parts.push({
                         text: sanitizeSurrogates(block.text),
                         ...(thoughtSignature && { thoughtSignature })
                     });
                 }
                 else if (block.type === 'thinking') {
-                    // Skip empty thinking blocks
-                    if (!block.thinking || block.thinking.trim() === '')
+                    const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thinkingSignature);
+                    if (!thoughtSignature && (!block.thinking || block.thinking.trim() === ''))
                         continue;
                     // Only keep as thinking block if same provider AND same model
                     // Otherwise convert to plain text (no tags to avoid model mimicking them)
                     if (isSameProviderAndModel) {
-                        const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thinkingSignature);
                         parts.push({
                             thought: true,
                             text: sanitizeSurrogates(block.thinking),
@@ -144,12 +161,10 @@ export function convertMessages(model, context) {
                 }
                 else if (block.type === 'toolCall') {
                     const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature);
-                    // Gemini 3 requires thoughtSignature on all function calls when thinking mode is enabled.
-                    // When replaying history from providers without thought signatures,
-                    // convert unsigned function calls to text to avoid API validation errors.
-                    // We include a note telling the model this is historical context to prevent mimicry.
+                    // Only the first parallel call needs a signature. If it is missing (foreign
+                    // or older persisted history), retain the historical-text fallback for the batch.
                     const isGemini3 = model.id.toLowerCase().includes('gemini-3');
-                    if (isGemini3 && !thoughtSignature) {
+                    if (isGemini3 && !hasSignedToolCalls) {
                         const argsStr = JSON.stringify(block.arguments ?? {}, null, 2);
                         parts.push({
                             text: `[Historical context: a different model called tool "${block.name}" with arguments: ${argsStr}. Do not mimic this format - use proper function calling.]`