mixdog 0.9.40 → 0.9.43

package/src/runtime/agent/orchestrator/session/agent-loop.mjs

@@ -83,7 +83,7 @@ import {
     restoreToolCallBodyForId,
 } from './loop/stored-tool-args.mjs';
 import { repairTranscriptBeforeProviderSend } from './loop/transcript-repair.mjs';
-import { classifyTerminationReason, INCOMPLETE_STOP_REASONS } from './loop/termination.mjs';
+import { classifyTerminationReason, INCOMPLETE_STOP_REASONS, isOutputLimitStopReason } from './loop/termination.mjs';
 import { createSteeringLadder } from './loop/steering-ladder.mjs';
 import { runPreSendCompactPass } from './pre-send-compact.mjs';
 import { createEagerDispatcher } from './eager-dispatch.mjs';
@@ -116,6 +116,11 @@ export {
 // this catches tight deterministic-failure loops (e.g. a command that errors
 // the same way every time) far earlier than 100 iterations.
 const REPEAT_FAIL_LIMIT = 3;
+// A provider max-output stop is not a completed assistant turn, even when it
+// contains useful text. Preserve each partial in the provider transcript and
+// grant at most three direct continuations before surfacing a hard truncation.
+const MAX_OUTPUT_RECOVERY_LIMIT = 3;
+const MAX_OUTPUT_EXHAUSTED_NOTICE = '[mixdog-runtime] Output remained truncated after 3 continuation attempts.';
 // _scopedCacheOutcomeForCall and executeTool moved to ./loop/tool-exec.mjs
 // (imported above).
 /**
@@ -140,6 +145,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     let lastUsage;
     let firstTurnUsage;
     let response;
+    let lastSendTools = tools;
     let contextOverflowRetryUsed = false;
     // Set when the hard iteration-cap break below fires. Consumed at the final
     // return to tag terminationReason='iteration_cap' so a worker that exhausts
@@ -233,10 +239,16 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         const reasoningItems = Array.isArray(resp.reasoningItems) && resp.reasoningItems.length
             ? resp.reasoningItems
             : null;
-        if (!content && !reasoningContent && !reasoningItems) return false;
+        const thinkingBlocks = Array.isArray(resp.thinkingBlocks) && resp.thinkingBlocks.length
+            ? resp.thinkingBlocks
+            : null;
+        if (!content && !reasoningContent && !reasoningItems && !thinkingBlocks) return false;
         messages.push({
             role: 'assistant',
             content,
+            // Anthropic adaptive-thinking signatures must be replayed verbatim
+            // before the continuation turn, just like tool-call trajectories.
+            ...(thinkingBlocks ? { thinkingBlocks } : {}),
             ...(reasoningItems ? { reasoningItems } : {}),
             ...(reasoningContent ? { reasoningContent } : {}),
         });
@@ -270,6 +282,9 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     // the loop as an explicit empty termination instead.
     let _emptyNudgeStreak = 0;
     const EMPTY_NUDGE_MAX = 3;
+    let _refusalRetryUsed = false;
+    let _maxOutputRecoveryCount = 0;
+    const _maxOutputContentParts = [];
     // Claude Code parity: queued prompt/task notifications are attached after a
     // tool batch, before the continuation provider send. Normal batches drain
     // up to 'next'; a Sleep-like tool grants a 'later' flush.
@@ -422,6 +437,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         const sendTools = _capFinalToolsDisabled
             ? tools
             : (forcedFirstToolDef && toolCallsTotal === 0 ? [forcedFirstToolDef] : tools);
+        lastSendTools = sendTools;
         // Eager-dispatch queue: when the provider streams a tool-call event,
         // start read-only tools immediately so execution overlaps with the
         // remaining SSE parse. Writes and unknown tools wait until send()
@@ -517,22 +533,15 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         // Provider may have returned despite an abort (SDKs that don't honour
         // signal) — bail before processing any of its output.
         throwIfAborted();
-        // P1 audit fix (Step4): a text-only turn truncated by the provider's
-        // max-output limit (response.truncated, set by the provider layer
-        // when stopReason==='length' AND content is non-empty) used to look
-        // identical to a clean completion — the model's answer could be
-        // silently cut mid-sentence with zero signal to the operator. Surface
-        // it as a one-line stderr warning + trace event WITHOUT failing the
-        // turn (the partial content is still usable and the loop's own
-        // isIncompleteStop nudge below already re-prompts when content is
-        // empty).
+        // Keep a diagnostic for every provider-declared truncation. Eligible
+        // no-tool text turns are recovered below rather than accepted as final.
         if (response?.truncated === true) {
             try {
                 process.stderr.write(
                     `[loop] provider output truncated at max-output limit (sess=${sessionId || 'unknown'} `
                     + `iter=${iterations} stopReason=${response.stopReason ?? response.stop_reason ?? 'length'} `
                     + `contentLen=${typeof response.content === 'string' ? response.content.length : 0}); `
-                    + `answer may be cut off mid-sentence.\n`,
+                    + `continuation recovery will be attempted when eligible.\n`,
                 );
             } catch { /* best-effort */ }
             try {
@@ -566,6 +575,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                     // additive — callers that ignore these fields keep working.
                     deltaCachedRead: response.usage.cachedTokens || 0,
                     deltaCacheWrite: response.usage.cacheWriteTokens || 0,
+                    sendTools,
                     ts: Date.now(),
                 });
             } catch { /* best-effort — never break the loop */ }
@@ -600,6 +610,46 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             const isHidden = HIDDEN_AGENT_NAMES.has(sessionAgent);
             const stopReason = response.stopReason ?? response.stop_reason ?? null;
             const isIncompleteStop = stopReason && INCOMPLETE_STOP_REASONS.has(stopReason);
+            const isOutputLimitStop = isOutputLimitStopReason(stopReason);
+            if (hasContent && isOutputLimitStop) {
+                _maxOutputContentParts.push(response.content);
+                if (_maxOutputRecoveryCount < MAX_OUTPUT_RECOVERY_LIMIT) {
+                    // The partial assistant turn must be visible to the model so
+                    // it can resume at the exact cutoff instead of reconstructing
+                    // or repeating it. askSession persists this natural recovery
+                    // chain; historyContent below prevents the aggregate returned
+                    // to callers from being persisted a second time.
+                    pushIntermediateAssistantResponse(response);
+                    _maxOutputRecoveryCount += 1;
+                    messages.push({
+                        role: 'user',
+                        content: 'Output token limit hit. Resume directly — no apology, no recap. Pick up exactly where the previous text stopped.',
+                        meta: { source: 'max-output-recovery', attempt: _maxOutputRecoveryCount },
+                    });
+                    continue;
+                }
+                const terminalSegment = `${response.content}\n\n${MAX_OUTPUT_EXHAUSTED_NOTICE}`;
+                response = {
+                    ...response,
+                    content: `${_maxOutputContentParts.slice(0, -1).join('')}${terminalSegment}`,
+                    historyContent: terminalSegment,
+                    maxOutputRecoveryAttempts: _maxOutputRecoveryCount,
+                };
+                break;
+            }
+            if (!hasContent && stopReason === 'refusal') {
+                if (_refusalRetryUsed) {
+                    process.stderr.write(`[loop] safety-classifier refusal persisted after one context-changing retry (sess=${sessionId || 'unknown'}); ending loop as refusal termination.\n`);
+                    break;
+                }
+                _refusalRetryUsed = true;
+                messages.push({
+                    role: 'user',
+                    content: '[mixdog-runtime] The previous completion was refused by the provider safety classifier (stopReason=refusal). Do not repeat it. Complete your assigned output within policy by omitting or reframing disallowed content; if no compliant output is possible, briefly state the refusal.',
+                    meta: { source: 'refusal-recovery', attempt: 1 },
+                });
+                continue;
+            }
             if (!hasContent && !isHidden) {
                 _emptyNudgeStreak += 1;
                 if (_emptyNudgeStreak > EMPTY_NUDGE_MAX) {
@@ -622,6 +672,15 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 messages.push({ role: 'user', content: nudgeMsg });
                 continue;
             }
+            if (_maxOutputContentParts.length > 0) {
+                const terminalSegment = typeof response.content === 'string' ? response.content : '';
+                response = {
+                    ...response,
+                    content: `${_maxOutputContentParts.join('')}${terminalSegment}`,
+                    historyContent: terminalSegment,
+                    maxOutputRecoveryAttempts: _maxOutputRecoveryCount,
+                };
+            }
             break;
         }
         _emptyNudgeStreak = 0;
@@ -709,6 +768,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         ...response,
         usage: lastUsage || response.usage,
         lastTurnUsage: response.usage,
+        lastSendTools,
         firstTurnUsage: firstTurnUsage || response.usage,
         iterations,
         toolCallsTotal,

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -1,6 +1,7 @@
 import { isOffloadedToolResultText } from './tool-result-offload.mjs';
 import { createHash } from 'node:crypto';
 import { isAgentOwner } from '../agent-owner.mjs';
+import { contentImageDescriptors, contentToText } from '../providers/media-normalization.mjs';
 
 // ---------------------------------------------------------------------------
 // Conservative, Unicode-aware token estimator.
@@ -26,6 +27,8 @@ function readSafetyMultiplier() {
     return 1.1;
 }
 const TOKEN_ESTIMATE_SAFETY_MULTIPLIER = readSafetyMultiplier();
+export const IMAGE_VISUAL_TOKEN_ALLOWANCE = 4_096;
+const IMAGE_TILE_TOKEN_ALLOWANCE = 512;
 
 // Per-code-point token-cost weight. Tuned to overcount, not match exactly.
 function codePointTokenWeight(cp) {
@@ -72,12 +75,59 @@ export function estimateTokens(text) {
     if (s.length === 0) return 0;
     let weighted = 0;
     for (const ch of s) weighted += codePointTokenWeight(ch.codePointAt(0));
+    // Encoded blobs, minified JSON and generated identifiers do not get the
+    // word/whitespace merges that make prose approach chars/4. Long printable
+    // ASCII runs are commonly 0.5-0.8 tokens/byte; retain a conservative floor
+    // for those runs without penalizing ordinary spaced prose.
+    let denseAsciiFloor = 0;
+    for (const match of s.matchAll(/[\x21-\x7e]{16,}/g)) {
+        denseAsciiFloor += match[0].length * 0.75;
+    }
+    const encodedWords = s.match(/\b(?=[A-Za-z0-9]{8,}\b)(?=[A-Za-z0-9]*[A-Za-z])(?=[A-Za-z0-9]*\d)[A-Za-z0-9]+\b/g) || [];
+    if (encodedWords.length >= 3) {
+        // Encoded/generated identifiers are often wrapped at short columns or
+        // separated by spaces. Their individual runs can stay below the long-
+        // run threshold while still receiving almost no prose-style BPE merges.
+        const encodedChars = encodedWords.reduce((sum, word) => sum + word.length, 0);
+        denseAsciiFloor = Math.max(
+            denseAsciiFloor,
+            (encodedChars * 0.75) + ((s.length - encodedChars) * 0.25),
+        );
+    }
+    const lines = s.split(/\r?\n/).filter(line => line.trim());
+    const nonWhitespace = s.match(/\S/g)?.length || 0;
+    const structural = s.match(/[\[\]{}":,=<>|\\]/g)?.length || 0;
+    const jsonLikeLines = lines.filter(line => /^\s*[\[{].*[\]}],?\s*$/.test(line)).length;
+    if (lines.length >= 3 && nonWhitespace > 0
+        && (jsonLikeLines >= Math.ceil(lines.length / 2) || structural / nonWhitespace >= 0.12)) {
+        // JSONL, compact tables and generated line protocols can consist
+        // entirely of short runs while still tokenizing like minified data.
+        denseAsciiFloor = Math.max(denseAsciiFloor, (nonWhitespace * 0.7) + ((s.length - nonWhitespace) * 0.25));
+    }
     const asciiFloor = s.length / 4; // never below the legacy chars/4 lower bound
-    return Math.ceil(Math.max(weighted, asciiFloor) * TOKEN_ESTIMATE_SAFETY_MULTIPLIER);
+    return Math.ceil(Math.max(weighted, asciiFloor, denseAsciiFloor) * TOKEN_ESTIMATE_SAFETY_MULTIPLIER);
+}
+
+function nativeBlocksEstimateText(value) {
+    const list = Array.isArray(value) ? value : [value];
+    return list.map((block) => {
+        const images = contentImageDescriptors(block);
+        if (images.length) {
+            return JSON.stringify(images.map(({ width, height, detail }) => ({
+                type: 'image', width, height, detail,
+            })));
+        }
+        try { return JSON.stringify(block); }
+        catch { return String(block ?? ''); }
+    }).join('\n');
 }
 export function messageEstimateText(m) {
     if (!m || typeof m !== 'object') return '';
-    let text = typeof m.content === 'string' ? m.content : JSON.stringify(m.content ?? '');
+    // Multimodal image payloads remain on the live message for provider sends,
+    // but their base64/data-url JSON is not text and must not dominate local
+    // context estimates. Use the same media-aware text projection for every
+    // estimate consumer (live gauge, compaction fallback, and summaries).
+    let text = contentToText(m.content, '');
     if (m.role === 'assistant' && Array.isArray(m.toolCalls) && m.toolCalls.length) {
         try { text += `\n${JSON.stringify(m.toolCalls)}`; }
         catch { text += `\n[${m.toolCalls.length} tool calls]`; }
@@ -86,14 +136,47 @@ export function messageEstimateText(m) {
     // signature / redacted data) and are re-sent on tool-continuation turns, so
     // they consume real input tokens. Count them or trim/compact undercounts.
     if (m.role === 'assistant' && Array.isArray(m.thinkingBlocks) && m.thinkingBlocks.length) {
-        try { text += `\n${JSON.stringify(m.thinkingBlocks)}`; }
-        catch { text += `\n[${m.thinkingBlocks.length} thinking blocks]`; }
+        text += `\n${nativeBlocksEstimateText(m.thinkingBlocks)}`;
+    }
+    // Some provider adapters replay their native assistant representation
+    // instead of content/toolCalls. Project it through the media normalizer so
+    // text/tool metadata and opaque reasoning are counted without base64 image
+    // bytes dominating the estimate.
+    if (m.role === 'assistant' && Array.isArray(m.assistantBlocks) && m.assistantBlocks.length) {
+        text += `\n${nativeBlocksEstimateText(m.assistantBlocks)}`;
+    }
+    if (m.role === 'assistant' && Array.isArray(m.reasoningItems) && m.reasoningItems.length) {
+        text += `\n${nativeBlocksEstimateText(m.reasoningItems)}`;
     }
     if (m.role === 'tool' && m.toolCallId) text += `\n${m.toolCallId}`;
     return text;
 }
+function imageDescriptorAllowance(descriptor) {
+    if (descriptor.width && descriptor.height) {
+        const tiles = Math.ceil(descriptor.width / 512) * Math.ceil(descriptor.height / 512);
+        // Caller-supplied dimensions/detail are not uniformly preserved by all
+        // provider normalizers, so they may raise the allowance for a known
+        // multi-tile image but can never lower the conservative unknown-image
+        // fallback. This avoids trusting metadata the provider never sees.
+        return Math.max(IMAGE_VISUAL_TOKEN_ALLOWANCE, IMAGE_TILE_TOKEN_ALLOWANCE * (tiles + 1));
+    }
+    // Unknown-size auto/high images may be tiled by the provider. A single
+    // 1k allowance is optimistic for common screenshots and documents.
+    return IMAGE_VISUAL_TOKEN_ALLOWANCE;
+}
+function messageImageDescriptors(m) {
+    if (!m || typeof m !== 'object') return [];
+    return [
+        ...contentImageDescriptors(m.content),
+        ...(m.role === 'assistant' ? contentImageDescriptors(m.assistantBlocks) : []),
+    ];
+}
+function messageImageAllowance(m) {
+    if (!m || typeof m !== 'object') return 0;
+    return messageImageDescriptors(m).reduce((sum, descriptor) => sum + imageDescriptorAllowance(descriptor), 0);
+}
 export function estimateMessageTokens(m) {
-    return estimateTokens(messageEstimateText(m)) + 4;
+    return estimateTokens(messageEstimateText(m)) + messageImageAllowance(m) + 4;
 }
 export function estimateMessagesTokens(messages) {
     return messages.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
@@ -112,28 +195,11 @@ const contextMessageMemo = new WeakMap();
 const contextTranscriptMemo = new WeakMap();
 
 function contextValueFingerprint(value) {
-    if (typeof value === 'string') return { value, entries: null };
-    if (Array.isArray(value)) return {
-        value,
-        entries: value.map(contextBlockFingerprint),
-    };
-    return value && typeof value === 'object'
-        ? { value, entries: [contextBlockFingerprint(value)] }
-        : { value, entries: null };
-}
-
-function contextBlockFingerprint(block) {
-    if (!block || typeof block !== 'object') return { value: block };
-    const fn = block.function;
     return {
-        value: block,
-        text: typeof block.text === 'string' ? block.text : null,
-        content: typeof block.content === 'string' ? block.content : null,
-        args: typeof block.args === 'string' ? block.args : null,
-        arguments: block.arguments,
-        input: typeof block.input === 'string' ? block.input : null,
-        function: fn,
-        functionArguments: typeof fn?.arguments === 'string' ? fn.arguments : null,
+        value,
+        snapshot: typeof value === 'string'
+            ? value
+            : `${nativeBlocksEstimateText(value)}\0${JSON.stringify(contentImageDescriptors(value))}`,
     };
 }
 
@@ -145,6 +211,7 @@ function contextMessageFingerprint(message) {
             toolCalls: contextValueFingerprint(null),
             thinkingBlocks: contextValueFingerprint(null),
             assistantBlocks: contextValueFingerprint(null),
+            reasoningItems: contextValueFingerprint(null),
             toolCallId: null,
         };
     }
@@ -154,30 +221,13 @@ function contextMessageFingerprint(message) {
         toolCalls: contextValueFingerprint(message.toolCalls),
         thinkingBlocks: contextValueFingerprint(message.thinkingBlocks),
         assistantBlocks: contextValueFingerprint(message.assistantBlocks),
+        reasoningItems: contextValueFingerprint(message.reasoningItems),
         toolCallId: message?.toolCallId || null,
     };
 }
 
 function sameContextValueFingerprint(a, b) {
-    if (!a || !b || a.value !== b.value) return false;
-    if (a.entries === null || b.entries === null) return a.entries === b.entries;
-    if (a.entries.length !== b.entries.length) return false;
-    for (let index = 0; index < a.entries.length; index += 1) {
-        if (!sameContextBlockFingerprint(a.entries[index], b.entries[index])) return false;
-    }
-    return true;
-}
-
-function sameContextBlockFingerprint(a, b) {
-    return !!a && !!b
-        && a.value === b.value
-        && a.text === b.text
-        && a.content === b.content
-        && a.args === b.args
-        && Object.is(a.arguments, b.arguments)
-        && a.input === b.input
-        && a.function === b.function
-        && a.functionArguments === b.functionArguments;
+    return !!a && !!b && a.value === b.value && a.snapshot === b.snapshot;
 }
 
 function sameContextMessageFingerprint(a, b) {
@@ -186,6 +236,7 @@ function sameContextMessageFingerprint(a, b) {
         && sameContextValueFingerprint(a.toolCalls, b.toolCalls)
         && sameContextValueFingerprint(a.thinkingBlocks, b.thinkingBlocks)
         && sameContextValueFingerprint(a.assistantBlocks, b.assistantBlocks)
+        && sameContextValueFingerprint(a.reasoningItems, b.reasoningItems)
         && a.toolCallId === b.toolCallId;
 }
 
@@ -197,7 +248,7 @@ function contextMessageContribution(message) {
     }
     const role = ['system', 'user', 'assistant', 'tool'].includes(fingerprint.role) ? fingerprint.role : 'other';
     const text = messageEstimateText(message);
-    const tokens = estimateTokens(text) + 4;
+    const tokens = estimateTokens(text) + messageImageAllowance(message) + 4;
     const contribution = {
         role,
         tokens,
@@ -307,6 +358,7 @@ function contextSummaryResult(state, count) {
 
 export const DEFAULT_COMPACTION_BUFFER_TOKENS = 0;
 export const DEFAULT_COMPACTION_BUFFER_RATIO = 0.1;
+export const MAIN_COMPACTION_TRIGGER_RATIO = 0.95;
 export const MAX_COMPACTION_BUFFER_RATIO = 0.25;
 export const DEFAULT_COMPACTION_KEEP_TOKENS = 8_000;
 const LEGACY_DEFAULT_COMPACTION_BUFFER_RATIO = 0.1;
@@ -443,8 +495,8 @@ export function resolveCompactTriggerTokens(sessionOrConfig = {}, boundaryTokens
 //     (trigger = limit) for every session type;
 //   - agent-owned semantic sessions otherwise keep the default early-trigger
 //     buffer (config-driven, default 10% -> compact at 90% of the boundary);
-//   - main/user recall-fasttrack sessions have NO default buffer and compact on
-//     the boundary itself (100%).
+//   - main/user recall-fasttrack sessions keep 5% headroom and compact at 95%
+//     of the effective boundary.
 // Returns the sanitized explicit limit (null when absent/legacy full-window)
 // plus triggerTokens / bufferTokens / bufferRatio for the given boundary.
 export function resolveSessionCompactPolicy(sessionOrConfig = {}, boundaryTokens = 0) {
@@ -466,7 +518,7 @@ export function resolveSessionCompactPolicy(sessionOrConfig = {}, boundaryTokens
     } else if (isAgentOwner(sessionOrConfig)) {
         triggerTokens = Math.max(1, boundary - resolveCompactBufferTokens(boundary, cfg));
     } else {
-        triggerTokens = boundary;
+        triggerTokens = Math.max(1, Math.floor(boundary * MAIN_COMPACTION_TRIGGER_RATIO));
     }
     const bufferTokens = Math.max(0, boundary - triggerTokens);
     const bufferRatio = bufferTokens / boundary;
@@ -510,7 +562,7 @@ export function summarizeContextMessages(messages) {
     if (!Array.isArray(messages)) return contextSummaryResult(emptyContextSummaryState(), 0);
     let cached = contextTranscriptMemo.get(messages);
     if (!cached || messages.length < cached.count) {
-        cached = { count: 0, contributions: [], state: emptyContextSummaryState() };
+        cached = { count: 0, contributions: [], state: emptyContextSummaryState(), revision: 0 };
         contextTranscriptMemo.set(messages, cached);
     }
     for (let index = 0; index < messages.length; index += 1) {
@@ -520,12 +572,42 @@ export function summarizeContextMessages(messages) {
         if (previous) applyContextMessageContribution(cached.state, previous, -1);
         cached.contributions[index] = contribution;
         applyContextMessageContribution(cached.state, contribution, 1);
+        cached.revision += 1;
     }
     cached.contributions.length = messages.length;
     cached.count = messages.length;
     return contextSummaryResult(cached.state, messages.length);
 }
 
+// A stable warm-cache generation for consumers that cache a derived view of
+// the whole transcript. summarizeContextMessages() must run first so mutations
+// to any entry, not merely the tail, advance the generation.
+export function contextMessagesRevision(messages) {
+    if (!Array.isArray(messages)) return 0;
+    summarizeContextMessages(messages);
+    return contextTranscriptMemo.get(messages)?.revision || 0;
+}
+
+// Hash only estimator/provider-visible projections. In particular, images
+// contribute their visual count but never their raw data-url/base64 bytes.
+export function contextMessagesSignature(messages, count = messages?.length) {
+    const list = Array.isArray(messages) ? messages : [];
+    const end = Math.max(0, Math.min(list.length, Number.isInteger(count) ? count : list.length));
+    const hash = createHash('sha256');
+    for (let index = 0; index < end; index += 1) {
+        const message = list[index];
+        hash.update(JSON.stringify([
+            message?.role || '',
+            message?.toolCallId || '',
+            messageEstimateText(message),
+            messageImageAllowance(message),
+            messageImageDescriptors(message),
+        ]));
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
+
 // Per-request overhead the provider injects that never appears in the
 // `messages` array: function-calling preamble + system-prompt framing the
 // provider wraps around the request. The chars/4 message estimate misses all
@@ -534,35 +616,13 @@ const REQUEST_OVERHEAD_TOKENS = 512;
 const toolSchemaTokenMemo = new WeakMap();
 const requestReserveTokenMemo = new WeakMap();
 
-function sameToolArrayEntries(cached, tools) {
-    if (!cached || cached.entries.length !== tools.length) return false;
-    for (let index = 0; index < tools.length; index += 1) {
-        const entry = cached.entries[index];
-        const tool = tools[index];
-        if (entry.tool !== tool
-            || entry.name !== tool?.name
-            || entry.description !== tool?.description
-            || entry.inputSchema !== tool?.inputSchema
-            || entry.input_schema !== tool?.input_schema
-            || entry.parameters !== tool?.parameters
-            || entry.schema !== tool?.schema) return false;
-    }
-    return true;
+function serializeToolSchemas(tools) {
+    try { return JSON.stringify(Array.isArray(tools) ? tools : []); }
+    catch { return (Array.isArray(tools) ? tools : []).map(t => String(t?.name ?? '')).join(''); }
 }
 
-function cacheToolArrayValue(tools, value) {
-    return {
-        entries: tools.map((tool) => ({
-            tool,
-            name: tool?.name,
-            description: tool?.description,
-            inputSchema: tool?.inputSchema,
-            input_schema: tool?.input_schema,
-            parameters: tool?.parameters,
-            schema: tool?.schema,
-        })),
-        value,
-    };
+export function toolSchemaSignature(tools) {
+    return createHash('sha256').update(serializeToolSchemas(tools)).digest('hex');
 }
 
 /**
@@ -575,13 +635,12 @@ function cacheToolArrayValue(tools, value) {
  */
 export function estimateToolSchemaTokens(tools) {
     if (!Array.isArray(tools) || tools.length === 0) return 0;
+    const signature = toolSchemaSignature(tools);
     const cached = toolSchemaTokenMemo.get(tools);
-    if (sameToolArrayEntries(cached, tools)) return cached.value;
-    let text = '';
-    try { text = JSON.stringify(tools); }
-    catch { text = tools.map(t => String(t?.name ?? '')).join(''); }
+    if (cached?.signature === signature) return cached.value;
+    const text = serializeToolSchemas(tools);
     const tokens = estimateTokens(text);
-    toolSchemaTokenMemo.set(tools, cacheToolArrayValue(tools, tokens));
+    toolSchemaTokenMemo.set(tools, { signature, value: tokens });
     return tokens;
 }
 
@@ -593,10 +652,11 @@ export function estimateToolSchemaTokens(tools) {
  */
 export function estimateRequestReserveTokens(tools) {
     if (!Array.isArray(tools)) return estimateToolSchemaTokens(tools) + REQUEST_OVERHEAD_TOKENS;
+    const signature = toolSchemaSignature(tools);
     const cached = requestReserveTokenMemo.get(tools);
-    if (sameToolArrayEntries(cached, tools)) return cached.value;
+    if (cached?.signature === signature) return cached.value;
     const reserve = estimateToolSchemaTokens(tools) + REQUEST_OVERHEAD_TOKENS;
-    requestReserveTokenMemo.set(tools, cacheToolArrayValue(tools, reserve));
+    requestReserveTokenMemo.set(tools, { signature, value: reserve });
     return reserve;
 }