@juspay/neurolink 11.15.7 → 11.15.9

package/dist/core/geminiLoopAdapter.js

@@ -49,10 +49,13 @@ export function createGeminiLoopAdapter(config) {
          * step is callable in the same step, before the next refresh.
          */
         buildStepRequest(conversation, step) {
-            if (config.declarations) {
-                refreshNativeToolDeclarations(config.liveTools, config.declarations);
-            }
-            return { raw: config.buildRequest(conversation, step) };
+            const hydratedToolNames = config.declarations
+                ? refreshNativeToolDeclarations(config.liveTools, config.declarations)
+                : [];
+            return {
+                raw: config.buildRequest(conversation, step),
+                ...(hydratedToolNames.length > 0 ? { hydratedToolNames } : {}),
+            };
         },
         /**
          * The engine decides WHEN to reclaim; the provider decides HOW. Wiring
@@ -62,10 +65,7 @@ export function createGeminiLoopAdapter(config) {
          */
         ...(config.planReclaim
             ? {
-                planReclaim: (conversation, step) => {
-                    const reclaimed = config.planReclaim?.(conversation, step);
-                    return reclaimed ? { conversation: reclaimed } : undefined;
-                },
+                planReclaim: (conversation, step) => config.planReclaim?.(conversation, step),
             }
             : {}),
         /**
@@ -120,13 +120,26 @@ export function createGeminiLoopAdapter(config) {
             config.noteUsage?.(collected.inputTokens, collected.outputTokens);
             const text = extractTextFromParts(collected.rawResponseParts);
             // Names cross the engine boundary in their ORIGINAL form.
-            const toolCalls = collected.stepFunctionCalls.map((call, index) => ({
+            const allCalls = collected.stepFunctionCalls.map((call, index) => ({
                 id: `${config.providerLabel}_${index}_${call.name}`,
                 name: originalNameFor(call.name),
                 args: call.args,
             }));
+            // A call to the terminal structured-output tool is not a tool call at
+            // all — its arguments ARE the answer. Reporting it as text and leaving
+            // it out of `toolCalls` routes it through the engine's ordinary
+            // zero-tool-calls exit, so it is never dispatched, never struck against
+            // the breaker, and never recorded as a tool execution.
+            const terminal = config.finalResultToolName
+                ? allCalls.find((call) => call.name === config.finalResultToolName)
+                : undefined;
+            const toolCalls = terminal ? [] : allCalls;
+            const finalText = terminal ? JSON.stringify(terminal.args) : text;
+            if (terminal) {
+                config.onTerminalResult?.(finalText);
+            }
             return {
-                text,
+                text: finalText,
                 toolCalls,
                 usage: {
                     inputTokens: collected.inputTokens,
@@ -145,7 +158,12 @@ export function createGeminiLoopAdapter(config) {
                 },
             };
         },
-        buildToolResultMessages(conversation, stepResult, toolResults) {
+        buildToolResultMessages(conversation, stepResult, toolResults, 
+        // Declared and unused: writing history needs no step number. It is here
+        // for the provider wrappers around this adapter, which record tool
+        // activity keyed by the loop's own step and must not count their own
+        // invocations to get it.
+        _step) {
             // Copied before `pushModelResponseToHistory` mutates it: the engine
             // treats the conversation as a value it hands in and gets back, so
             // mutating the caller's array in place would make a retried or
@@ -158,8 +176,13 @@ export function createGeminiLoopAdapter(config) {
                     functionResponse: {
                         // Back to the sanitized wire name the model actually called.
                         name: sanitizedNameFor(result.name),
+                        // The engine's own payload, verbatim. A blocked or burnt-out
+                        // tool is reported as { error, status, do_not_retry }, and those
+                        // extra fields are MODEL-VISIBLE instructions — re-wrapping just
+                        // the message drops the "do not call this again" hint and the
+                        // model keeps spending steps on a tool that will never work.
                         response: result.error
-                            ? { error: result.error }
+                            ? result.output
                             : { result: result.output },
                     },
                 })),

package/dist/core/loopEngine.js

@@ -30,6 +30,149 @@ function sumUsage(a, b) {
         reasoningTokens: (a.reasoningTokens ?? 0) + (b.reasoningTokens ?? 0) || undefined,
     };
 }
+/**
+ * Dispatch one step's tool calls.
+ *
+ * Split out of `runAgenticLoop` because it is the one part of the turn with
+ * its own decision tree — breaker, hydration, execution, failure
+ * classification — and reading the loop should not mean reading all of it.
+ * It owns no state: everything it needs arrives as arguments, and it reports
+ * what happened by returning it, so the turn's accumulators stay in one place.
+ */
+async function dispatchStepTools(params) {
+    const { calls, adapter, tools, failedTools, abortSignal } = params;
+    const toolResults = [];
+    const executions = [];
+    const dispatched = [];
+    let abortedMidBatch = false;
+    for (const call of calls) {
+        // Honour an abort BETWEEN tool executions. A step can carry several calls,
+        // and each one costs up to a full tool timeout, so without this a wide
+        // batch keeps running long past the moment the turn was cancelled — the
+        // step-top check only fires once the whole batch has drained. Passing the
+        // signal into execute() is not enough on its own: a tool that ignores it
+        // runs to completion, and every remaining call still gets STARTED.
+        if (abortSignal.aborted) {
+            abortedMidBatch = true;
+            break;
+        }
+        dispatched.push(call);
+        const breaker = adapter.toolFailureBreaker;
+        const failInfo = breaker ? failedTools.get(call.name) : undefined;
+        if (breaker && failInfo && failInfo.count >= breaker.maxRetries) {
+            const output = {
+                error: `TOOL_PERMANENTLY_FAILED: "${call.name}" has failed ${failInfo.count} times. Last error: ${failInfo.lastError}.`,
+                status: "permanently_failed",
+                do_not_retry: true,
+            };
+            toolResults.push({
+                ...call,
+                output,
+                error: output.error,
+                permanentlyFailed: true,
+            });
+            executions.push({
+                id: call.id,
+                name: call.name,
+                input: call.args,
+                output,
+                error: output.error,
+            });
+            continue;
+        }
+        // Second lookup path for adapters that discover tools mid-turn.
+        // The miss is defined as "nothing executable under this name"
+        // rather than "no key under this name", because the guard directly
+        // below already treats a present-but-unexecutable entry as absent —
+        // a deferred-catalog placeholder is exactly that shape, and it is
+        // precisely what hydration exists to resolve.
+        const declaredTool = tools?.[call.name];
+        const tool = declaredTool?.execute
+            ? declaredTool
+            : (adapter.resolveToolOnMiss?.(call.name) ?? declaredTool);
+        if (!tool?.execute) {
+            const output = breaker
+                ? {
+                    error: `TOOL_NOT_FOUND: "${call.name}" does not exist.`,
+                    status: "permanently_failed",
+                    do_not_retry: true,
+                }
+                : { error: `Tool not found: ${call.name}` };
+            toolResults.push({
+                ...call,
+                output,
+                error: output.error,
+                permanentlyFailed: !!breaker,
+            });
+            executions.push({
+                id: call.id,
+                name: call.name,
+                input: call.args,
+                output,
+                error: output.error,
+            });
+            continue;
+        }
+        try {
+            const output = await tool.execute(call.args, {
+                toolCallId: call.id,
+                abortSignal: abortSignal,
+            });
+            // A result can report failure without throwing — an MCP isError
+            // payload, a proxy-blocked call resolving with `{ error }`. When
+            // the breaker is told how to recognise those, they strike it
+            // exactly as a throw does; otherwise the model can grind on a
+            // blocked tool for the whole step budget.
+            const resultFailure = breaker?.classifyResultFailure?.(output);
+            if (breaker) {
+                if (resultFailure) {
+                    const current = failedTools.get(call.name) ?? {
+                        count: 0,
+                        lastError: "",
+                    };
+                    current.count++;
+                    current.lastError = resultFailure;
+                    failedTools.set(call.name, current);
+                }
+                else if (breaker.consecutive) {
+                    // Genuinely consecutive: a clean result clears the count, so
+                    // an argument-dependent soft error cannot accumulate its way
+                    // to disabling a tool that works.
+                    failedTools.delete(call.name);
+                }
+            }
+            toolResults.push({ ...call, output });
+            executions.push({
+                id: call.id,
+                name: call.name,
+                input: call.args,
+                output,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (breaker) {
+                const current = failedTools.get(call.name) ?? {
+                    count: 0,
+                    lastError: "",
+                };
+                current.count++;
+                current.lastError = message;
+                failedTools.set(call.name, current);
+            }
+            const output = { error: message, status: "failed" };
+            toolResults.push({ ...call, output, error: message });
+            executions.push({
+                id: call.id,
+                name: call.name,
+                input: call.args,
+                output,
+                error: message,
+            });
+        }
+    }
+    return { toolResults, executions, dispatched, abortedMidBatch };
+}
 /**
  * Run one adapter-parameterized agentic tool-calling turn. Owns the
  * maxSteps-bounded loop, generic tool dispatch (with an opt-in
@@ -73,11 +216,25 @@ export function runAgenticLoop(adapter, initialConversation, options) {
                 }
                 if (adapter.planReclaim) {
                     const reclaimed = adapter.planReclaim(conversation, step);
-                    if (reclaimed) {
+                    if (reclaimed?.conversation !== undefined) {
                         conversation = reclaimed.conversation;
                     }
+                    // A guard that could not reclaim enough room ends the turn HERE,
+                    // before the request goes out — stepping into a provider rejection
+                    // would lose every completed step of the turn.
+                    if (reclaimed?.stop) {
+                        break;
+                    }
                 }
                 const request = adapter.buildStepRequest(conversation, step);
+                // A tool that just became callable starts clean. Its TOOL_NOT_FOUND
+                // strikes were recorded against a name that genuinely did not resolve
+                // yet, and the breaker is consulted before the lookup, so without this
+                // a deferred tool the model named twice is refused for the rest of the
+                // turn at the exact moment it becomes usable.
+                for (const name of request.hydratedToolNames ?? []) {
+                    failedTools.delete(name);
+                }
                 // Pre-first-chunk 429/5xx retry: watch whether THIS attempt of
                 // THIS step pushes anything to the shared channel before it
                 // throws. `hasEmitted` resets at the top of every attempt
@@ -125,7 +282,8 @@ export function runAgenticLoop(adapter, initialConversation, options) {
                     malformedRetryUsed = true;
                     logger.warn(`[${adapter.providerLabel}] Malformed function call at step ${step + 1}/${adapter.maxSteps}; retrying once.`);
                     conversation =
-                        adapter.buildMalformedRetryNote?.(conversation) ?? conversation;
+                        adapter.buildMalformedRetryNote?.(conversation, step) ??
+                            conversation;
                     continue;
                 }
                 if (stepResult.toolCalls.length === 0) {
@@ -135,101 +293,27 @@ export function runAgenticLoop(adapter, initialConversation, options) {
                 if (step === adapter.maxSteps - 1) {
                     hadToolCallsAtCap = true;
                 }
-                const toolResults = [];
-                for (const call of stepResult.toolCalls) {
-                    allToolCalls.push(call);
-                    const breaker = adapter.toolFailureBreaker;
-                    const failInfo = breaker ? failedTools.get(call.name) : undefined;
-                    if (breaker && failInfo && failInfo.count >= breaker.maxRetries) {
-                        const output = {
-                            error: `TOOL_PERMANENTLY_FAILED: "${call.name}" has failed ${failInfo.count} times. Last error: ${failInfo.lastError}.`,
-                            status: "permanently_failed",
-                            do_not_retry: true,
-                        };
-                        toolResults.push({
-                            ...call,
-                            output,
-                            error: output.error,
-                            permanentlyFailed: true,
-                        });
-                        allToolExecutions.push({
-                            id: call.id,
-                            name: call.name,
-                            input: call.args,
-                            output,
-                            error: output.error,
-                        });
-                        continue;
-                    }
-                    // Second lookup path for adapters that discover tools mid-turn.
-                    // The miss is defined as "nothing executable under this name"
-                    // rather than "no key under this name", because the guard directly
-                    // below already treats a present-but-unexecutable entry as absent —
-                    // a deferred-catalog placeholder is exactly that shape, and it is
-                    // precisely what hydration exists to resolve.
-                    const declaredTool = options.tools?.[call.name];
-                    const tool = declaredTool?.execute
-                        ? declaredTool
-                        : (adapter.resolveToolOnMiss?.(call.name) ?? declaredTool);
-                    if (!tool?.execute) {
-                        const output = breaker
-                            ? {
-                                error: `TOOL_NOT_FOUND: "${call.name}" does not exist.`,
-                                status: "permanently_failed",
-                                do_not_retry: true,
-                            }
-                            : { error: `Tool not found: ${call.name}` };
-                        toolResults.push({
-                            ...call,
-                            output,
-                            error: output.error,
-                            permanentlyFailed: !!breaker,
-                        });
-                        allToolExecutions.push({
-                            id: call.id,
-                            name: call.name,
-                            input: call.args,
-                            output,
-                            error: output.error,
-                        });
-                        continue;
-                    }
-                    try {
-                        const output = await tool.execute(call.args, {
-                            toolCallId: call.id,
-                            abortSignal: internalAbort.signal,
-                        });
-                        toolResults.push({ ...call, output });
-                        allToolExecutions.push({
-                            id: call.id,
-                            name: call.name,
-                            input: call.args,
-                            output,
-                        });
-                    }
-                    catch (err) {
-                        const message = err instanceof Error ? err.message : String(err);
-                        if (breaker) {
-                            const current = failedTools.get(call.name) ?? {
-                                count: 0,
-                                lastError: "",
-                            };
-                            current.count++;
-                            current.lastError = message;
-                            failedTools.set(call.name, current);
-                        }
-                        const output = { error: message, status: "failed" };
-                        toolResults.push({ ...call, output, error: message });
-                        allToolExecutions.push({
-                            id: call.id,
-                            name: call.name,
-                            input: call.args,
-                            output,
-                            error: message,
-                        });
-                    }
+                const dispatch = await dispatchStepTools({
+                    calls: stepResult.toolCalls,
+                    adapter,
+                    tools: options.tools,
+                    failedTools,
+                    abortSignal: internalAbort.signal,
+                });
+                const toolResults = dispatch.toolResults;
+                allToolCalls.push(...dispatch.dispatched);
+                allToolExecutions.push(...dispatch.executions);
+                const abortedMidBatch = dispatch.abortedMidBatch;
+                // A batch cut short leaves some calls without results, and the
+                // tool-result turn is appended as one message: writing it here would
+                // put an unanswered tool call into history. Anthropic rejects exactly
+                // that on the next request, and Gemini carries a dangling call
+                // forward. Break instead, leaving history ending on the model turn —
+                // which is a valid place to stop.
+                if (abortedMidBatch) {
+                    break;
                 }
-                conversation = adapter.buildToolResultMessages(conversation, stepResult, toolResults);
+                conversation = adapter.buildToolResultMessages(conversation, stepResult, toolResults, step);
             }
             const finishReason = adapter.mapFinishReason(rawStopReason, hadToolCallsAtCap);
             return {

package/dist/providers/anthropic/client.js

@@ -1637,7 +1637,7 @@ export class AnthropicProvider extends BaseProvider {
             // instead would batch every step's tools into one late write.
             const adapter = {
                 ...baseAdapter,
-                buildToolResultMessages: (conversation, stepResult, toolResults) => {
+                buildToolResultMessages: (conversation, stepResult, toolResults, engineStep) => {
                     for (const result of toolResults) {
                         toolsUsed.push(result.name);
                     }
@@ -1673,7 +1673,7 @@ export class AnthropicProvider extends BaseProvider {
                                 : String(storageErr),
                         });
                     });
-                    return baseAdapter.buildToolResultMessages(conversation, stepResult, toolResults);
+                    return baseAdapter.buildToolResultMessages(conversation, stepResult, toolResults, engineStep);
                 },
             };
             // Presented in the shape the engine dispatches through. The engine

package/dist/providers/googleAiStudio/client.js

@@ -769,7 +769,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                     return undefined;
                                 }
                                 contextGuard.resetAfterReclaim();
-                                return working;
+                                return { conversation: working };
                             },
                         });
                         // Wrapped because these fire once PER STEP in the loop this
@@ -779,8 +779,16 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         // late write and lose the per-step thought signature.
                         const adapter = {
                             ...baseAdapter,
-                            buildToolResultMessages: (contents, stepResult, toolResults) => {
-                                step++;
+                            buildToolResultMessages: (contents, stepResult, toolResults, engineStep) => {
+                                // The engine's own step, not a count of times this hook ran.
+                                // The two agree only while nothing skips the hook mid-turn:
+                                // a malformed-call retry `continue`s before it and still
+                                // consumes a step, so a self-incrementing counter drifts by
+                                // exactly the number of retries and mislabels every row
+                                // after the first. Values are unchanged for this provider
+                                // today — it enables no such retry — and stay correct if it
+                                // ever does.
+                                step = engineStep + 1;
                                 for (const call of stepResult.toolCalls) {
                                     span.addEvent("gen_ai.tool_call", {
                                         "tool.name": call.name,
@@ -822,7 +830,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                         });
                                     });
                                 }
-                                const next = baseAdapter.buildToolResultMessages(contents, stepResult, toolResults);
+                                const next = baseAdapter.buildToolResultMessages(contents, stepResult, toolResults, engineStep);
                                 // Project this step's growth: the appended tool results ride
                                 // the next prompt, which the provider has not reported on yet.
                                 try {
@@ -1093,13 +1101,15 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             return undefined;
                         }
                         contextGuard.resetAfterReclaim();
-                        return working;
+                        return { conversation: working };
                     },
                 });
                 const adapter = {
                     ...baseAdapter,
-                    buildToolResultMessages: (contents, stepResult, toolResults) => {
-                        step++;
+                    buildToolResultMessages: (contents, stepResult, toolResults, engineStep) => {
+                        // Same as the streaming twin: the engine's step, not a count of
+                        // hook invocations. See the comment there.
+                        step = engineStep + 1;
                         for (const call of stepResult.toolCalls) {
                             span.addEvent("gen_ai.tool_call", {
                                 "tool.name": call.name,
@@ -1134,7 +1144,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                 });
                             });
                         }
-                        const next = baseAdapter.buildToolResultMessages(contents, stepResult, toolResults);
+                        const next = baseAdapter.buildToolResultMessages(contents, stepResult, toolResults, engineStep);
                         try {
                             const appended = next[next.length - 1];
                             contextGuard.noteAppendedChars(JSON.stringify(appended?.parts ?? []).length);

package/dist/providers/googleNativeGemini3/utils.d.ts

@@ -9,7 +9,7 @@
  * providers so they can share a single implementation.
  */
 import type { GenerateStopReason, ThinkingConfig, AgenticLoopOptions, ChatMessage, CollectedChunkResult, MinimalChatMessage, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, StreamChannel, VertexNativePart, GeminiMultimodalInput, MultimodalAudioEntry } from "../../types/index.js";
-import type { Tool } from "../../types/index.js";
+import type { Tool, GeminiToolExecutionGuards } from "../../types/index.js";
 /**
  * A per-turn tool execute map that deduplicates identical tool calls.
  *
@@ -108,8 +108,8 @@ export declare function buildNativeToolDeclarations(tools: Record<string, Tool>,
  * identical in every test that calls a tool once, and silently reintroduces
  * duplicate side effects the moment the model repeats itself.
  */
-export declare function buildDedupedEngineTools(declarations: NativeToolDeclarationsResult | undefined, tools: Record<string, Tool> | undefined): NonNullable<AgenticLoopOptions["tools"]>;
-export declare function refreshNativeToolDeclarations(liveTools: Record<string, Tool> | undefined, current: NativeToolDeclarationsResult): boolean;
+export declare function buildDedupedEngineTools(declarations: NativeToolDeclarationsResult | undefined, tools: Record<string, Tool> | undefined, guards?: GeminiToolExecutionGuards): NonNullable<AgenticLoopOptions["tools"]>;
+export declare function refreshNativeToolDeclarations(liveTools: Record<string, Tool> | undefined, current: NativeToolDeclarationsResult): string[];
 /**
  * Build the native @google/genai config object shared by stream and generate.
  *

package/dist/providers/googleNativeGemini3/utils.js

@@ -18,6 +18,7 @@ import { resolveSamplingParams } from "../../models/modelRegistry.js";
 import { convertZodToJsonSchema, ensureNestedSchemaTypes, inlineJsonSchema, isZodSchema, normalizeJsonSchemaObject, } from "../../utils/schemaConversion.js";
 import { createNativeThinkingConfig } from "../../utils/thinkingConfig.js";
 import { resolveLiveTool } from "../../tools/toolDiscovery.js";
+import { raceWithAbort, withTimeout } from "../../utils/async/index.js";
 import { jsonSchema as aiJsonSchema, tool as createAISDKTool, } from "../../utils/tool.js";
 // ── Functions ──
 /** Stable, key-order-independent serialization of tool args for the dedup key. */
@@ -472,17 +473,50 @@ export function buildNativeToolDeclarations(tools, reservedNames) {
  * identical in every test that calls a tool once, and silently reintroduces
  * duplicate side effects the moment the model repeats itself.
  */
-export function buildDedupedEngineTools(declarations, tools) {
+export function buildDedupedEngineTools(declarations, tools, guards) {
     const engineTools = {};
+    /**
+     * Everything a loop needs around a tool call that the engine does not do
+     * itself, in one place so both the declared and the fallback path get it.
+     *
+     * Order matters. `raceWithAbort` sits INSIDE `withTimeout` so a turn-level
+     * abort is observed the moment it fires rather than after the tool settles,
+     * and the timeout still bounds a tool that neither settles nor honours its
+     * signal. The progress pings bracket the await because the stall watchdog
+     * is a whole-turn interval comparing wall-clock against the last progress
+     * mark — without them a legitimately slow tool reads as a stalled turn and
+     * gets killed.
+     */
+    const guard = (name, execute) => {
+        return async (args, opts) => {
+            const call = () => Promise.resolve(execute(args, opts));
+            if (!guards) {
+                return call();
+            }
+            guards.onProgress?.();
+            try {
+                const raced = guards.abortSignal
+                    ? raceWithAbort(call(), guards.abortSignal)
+                    : call();
+                return await (guards.toolTimeoutMs === undefined
+                    ? raced
+                    : withTimeout(raced, guards.toolTimeoutMs, `Tool "${name}" execution timed out after ${guards.toolTimeoutMs}ms`));
+            }
+            finally {
+                // In `finally`, not after a successful await: a tool that times out or
+                // throws has still consumed real time, and skipping the mark there
+                // would leave the watchdog measuring from before the call.
+                guards.onProgress?.();
+            }
+        };
+    };
     if (declarations) {
         for (const [safeName, originalName] of declarations.originalNameMap) {
             const execute = declarations.executeMap.get(safeName);
             if (!execute) {
                 continue;
             }
-            engineTools[originalName] = {
-                execute: async (args, opts) => execute(args, opts),
-            };
+            engineTools[originalName] = { execute: guard(originalName, execute) };
         }
         return engineTools;
     }
@@ -494,20 +528,18 @@ export function buildDedupedEngineTools(declarations, tools) {
         if (!execute) {
             continue;
         }
-        engineTools[name] = {
-            execute: async (args, opts) => execute(args, opts),
-        };
+        engineTools[name] = { execute: guard(name, execute) };
     }
     return engineTools;
 }
 export function refreshNativeToolDeclarations(liveTools, current) {
     if (!liveTools) {
-        return false;
+        return [];
     }
     const declaredOriginals = new Set(current.originalNameMap.values());
     const missing = Object.entries(liveTools).filter(([name]) => !declaredOriginals.has(name));
     if (missing.length === 0) {
-        return false;
+        return [];
     }
     const built = buildNativeToolDeclarations(Object.fromEntries(missing), new Set(current.originalNameMap.keys()));
     current.toolsConfig[0].functionDeclarations.push(...built.toolsConfig[0].functionDeclarations);
@@ -520,7 +552,12 @@ export function refreshNativeToolDeclarations(liveTools, current) {
     logger.info(`[buildNativeToolDeclarations] ${missing.length} tool(s) hydrated mid-turn via discovery: ${missing
         .map(([name]) => name)
         .join(", ")}`);
-    return true;
+    // The ORIGINAL names, which is what a caller's breaker is keyed by. A tool
+    // that accrued TOOL_NOT_FOUND strikes while it was still deferred was never
+    // really failing — those strikes are snapshot artifacts, and leaving them in
+    // place disables the tool for the rest of the turn at the very moment it
+    // becomes callable.
+    return missing.map(([name]) => name);
 }
 /**
  * Build the native @google/genai config object shared by stream and generate.