@juspay/neurolink 11.11.0 → 11.11.2

package/dist/lib/providers/anthropic/client.js

@@ -21,8 +21,9 @@ import { estimateTokens } from "../../utils/tokenEstimation.js";
 import { redactUrlCredentials } from "../../utils/logSanitize.js";
 import { ANTHROPIC_MAX_CACHE_BREAKPOINTS, applyAnthropicHistoryCacheBreakpoints, countAnthropicCacheMarkers, } from "../../utils/anthropicCacheBreakpoints.js";
 import { calculateCost } from "../../utils/pricing.js";
-import { resolveDeferredTool } from "../../tools/toolDiscovery.js";
 import { stringifyAnthropicToolOutput } from "./toolOutput.js";
+import { createAnthropicLoopAdapter } from "./loopAdapter.js";
+import { runAgenticLoop } from "../../core/loopEngine.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, mergeAbortSignals, } from "../../utils/timeout.js";
 import { resolveToolChoice } from "../../utils/toolChoice.js";
@@ -31,7 +32,6 @@ import { NoOutputGeneratedError } from "../../utils/generationErrors.js";
 import { buildNoOutputSentinel, stampNoOutputSpan, } from "../../utils/noOutputSentinel.js";
 import { convertZodToJsonSchema } from "../../utils/schemaConversion.js";
 import { resolveClaudeMaxTokens } from "../../utils/tokenLimits.js";
-import { withProviderRetry } from "../../utils/providerRetry.js";
 import { toAnthropicImageBlock, fileToAnthropicBlock, } from "../anthropicImageBlocks.js";
 import { resolveSamplingParams } from "../../models/modelRegistry.js";
 import { createDeferredAnalytics, stringifyToolInput, } from "../openaiChatCompletionsClient.js";
@@ -39,7 +39,7 @@ import { createStreamChannel } from "../../core/streamChannel.js";
 import { toNativeToolDeclarations } from "../../core/nativeToolFormat.js";
 import { ANTHROPIC_BETA_HEADERS } from "./constants.js";
 import { cacheControlOf } from "./cacheControl.js";
-import { appendFinalResultInstruction, appendFinalResultTool, FINAL_RESULT_TOOL_NAME, stringifyFinalResultInput, } from "./structuredOutput.js";
+import { appendFinalResultInstruction, appendFinalResultTool, FINAL_RESULT_TOOL_NAME, } from "./structuredOutput.js";
 // AnthropicProviderConfig is imported from types/providers.ts
 // Re-export for backward compatibility
 // Configuration helpers - now using consolidated utility
@@ -1495,32 +1495,21 @@ export class AnthropicProvider extends BaseProvider {
                 estimateTokens(text(tools), "anthropic"));
         };
         const runLoop = async () => {
-            const conversation = payload.messages.slice();
             // The provider's REAL prompt-token count for the previous step,
             // calibrating the guard's char-based estimate for free, paired with the
             // guard's own estimate for that same request — a ratio between counts of
             // two different payloads would be meaningless.
             let lastObservedPromptTokens;
             let lastSentEstimate;
-            for (let step = 0; step < maxSteps; step++) {
-                // Mid-turn discovery sync: search_tools (tools.discovery) hydrates
-                // new tools into toolsRecord between steps; Claude only calls tools
-                // declared in the request, so advertise them now (`params` below
-                // rebuilds from anthropicTools every step).
-                if (anthropicTools) {
-                    const declared = new Set(anthropicTools.map((t) => t.name));
-                    const hydrated = Object.fromEntries(Object.entries(toolsRecord).filter(([name]) => !declared.has(name)));
-                    if (Object.keys(hydrated).length > 0) {
-                        anthropicTools.push(...(toNativeToolDeclarations(hydrated, "input_schema") ?? []));
-                        logger.info(`[Anthropic] ${Object.keys(hydrated).length} tool(s) hydrated mid-turn via discovery: ${Object.keys(hydrated).join(", ")}`);
-                    }
-                }
-                // In-turn context guard. This loop appends an assistant tool_use
-                // message plus a user tool_result message every step — growth the
-                // pre-dispatch budget check never sees. Without it a long agentic run
-                // overflows the window mid-loop and loses every completed step.
-                // Returns undefined while the request still fits, leaving the history
-                // byte-identical so the rolling cache prefix below stays valid.
+            /**
+             * Reclaim, as a PURE function of the conversation.
+             *
+             * The hand-rolled loop this replaces rebuilt in place
+             * (`conversation.length = 0; conversation.push(...rebuilt)`) because it
+             * owned the array. The engine owns it now and assigns what this
+             * returns, so mutating here would corrupt a retried or reclaimed step.
+             */
+            const planReclaim = (conversation) => {
                 const reclaim = planAnthropicLoopReclaim({
                     conversation,
                     availableInputTokens: getAvailableInputTokens("anthropic", modelId, options.maxTokens ?? undefined),
@@ -1535,69 +1524,78 @@ export class AnthropicProvider extends BaseProvider {
                         lastSentEstimate = tokens;
                     },
                 });
-                if (reclaim) {
-                    // Applied HERE, in the loop's own concrete types: the guard decides,
-                    // the caller mutates. Dropping an assistant tool_use message together
-                    // with its user tool_result message is what keeps blocks paired.
-                    const dropSet = new Set(reclaim.drop);
-                    const truncateSet = new Set(reclaim.truncate);
-                    const rebuilt = [];
-                    for (let i = 0; i < conversation.length; i++) {
-                        if (dropSet.has(i)) {
-                            continue;
-                        }
-                        const message = conversation[i];
-                        if (truncateSet.has(i) && Array.isArray(message.content)) {
-                            rebuilt.push({
-                                ...message,
-                                content: message.content.map((block) => block.type === "tool_result"
-                                    ? {
-                                        ...block,
-                                        content: previewAnthropicToolResultText(typeof block.content === "string"
-                                            ? block.content
-                                            : (JSON.stringify(block.content) ?? "")),
-                                    }
-                                    : block),
-                            });
-                            continue;
-                        }
-                        rebuilt.push(message);
+                if (!reclaim) {
+                    return undefined;
+                }
+                // Dropping an assistant tool_use message together with its user
+                // tool_result message is what keeps blocks paired.
+                const dropSet = new Set(reclaim.drop);
+                const truncateSet = new Set(reclaim.truncate);
+                const rebuilt = [];
+                for (let i = 0; i < conversation.length; i++) {
+                    if (dropSet.has(i)) {
+                        continue;
                     }
-                    if (dropSet.size > 0) {
-                        // Anthropic requires user/assistant alternation around tool blocks;
-                        // the note is a user turn placed immediately before the first
-                        // surviving assistant tool_use turn, which preserves it.
-                        let noteIndex = rebuilt.findIndex((m) => Array.isArray(m.content) &&
-                            m.content.some((b) => b.type === "tool_use" || b.type === "tool_result"));
-                        if (noteIndex < 0) {
-                            noteIndex = Math.min(1, rebuilt.length);
-                        }
-                        rebuilt.splice(noteIndex, 0, {
-                            role: "user",
-                            content: [{ type: "text", text: ANTHROPIC_ELISION_NOTE }],
+                    const message = conversation[i];
+                    if (truncateSet.has(i) && Array.isArray(message.content)) {
+                        rebuilt.push({
+                            ...message,
+                            content: message.content.map((block) => block.type === "tool_result"
+                                ? {
+                                    ...block,
+                                    content: previewAnthropicToolResultText(typeof block.content === "string"
+                                        ? block.content
+                                        : (JSON.stringify(block.content) ?? "")),
+                                }
+                                : block),
                         });
+                        continue;
+                    }
+                    rebuilt.push(message);
+                }
+                if (dropSet.size > 0) {
+                    // Anthropic requires user/assistant alternation around tool blocks;
+                    // the note is a user turn placed immediately before the first
+                    // surviving assistant tool_use turn, which preserves it.
+                    let noteIndex = rebuilt.findIndex((m) => Array.isArray(m.content) &&
+                        m.content.some((b) => b.type === "tool_use" || b.type === "tool_result"));
+                    if (noteIndex < 0) {
+                        noteIndex = Math.min(1, rebuilt.length);
+                    }
+                    rebuilt.splice(noteIndex, 0, {
+                        role: "user",
+                        content: [{ type: "text", text: ANTHROPIC_ELISION_NOTE }],
+                    });
+                }
+                return rebuilt;
+            };
+            const buildParams = (conversation) => {
+                // Mid-turn discovery sync: search_tools (tools.discovery) hydrates
+                // new tools into toolsRecord between steps; Claude only calls tools
+                // declared in the request, so advertise them now.
+                if (anthropicTools) {
+                    const declared = new Set(anthropicTools.map((t) => t.name));
+                    const hydrated = Object.fromEntries(Object.entries(toolsRecord).filter(([name]) => !declared.has(name)));
+                    if (Object.keys(hydrated).length > 0) {
+                        const extra = toNativeToolDeclarations(hydrated, "input_schema");
+                        if (extra && extra.length > 0) {
+                            anthropicTools = [...anthropicTools, ...extra];
+                        }
                     }
-                    conversation.length = 0;
-                    conversation.push(...rebuilt);
                 }
                 // Prompt-cache parity with the native Vertex+Claude path — rolling
-                // history breakpoints, re-applied per step so the stable prefix
-                // stays byte-identical while the breakpoint follows the growing
-                // tail. Budget respects markers upstream layers already placed
-                // (system / last tool / message blocks) so the request never
-                // exceeds Anthropic's four-marker cap. Pure: `conversation` itself
-                // is never mutated, so re-counting per step stays stable.
+                // history breakpoints, re-applied per step so the stable prefix stays
+                // byte-identical while the breakpoint follows the growing tail.
                 const cacheMarkersUsed = countAnthropicCacheMarkers({
                     system: payload.system,
                     tools: anthropicTools,
                     messages: conversation,
                 });
                 const cachedConversation = applyAnthropicHistoryCacheBreakpoints(conversation, ANTHROPIC_MAX_CACHE_BREAKPOINTS - cacheMarkersUsed);
-                // Registry-driven strip (Sonnet 5 / Opus 4.7+ / Fable 5 families)
                 const streamSamplingParams = resolveSamplingParams("anthropic", modelId, options.temperature !== undefined && options.temperature !== null
                     ? { temperature: options.temperature }
                     : {}, "anthropic.executeStream");
-                const params = {
+                return {
                     model: modelId,
                     messages: cachedConversation,
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxTokens),
@@ -1612,239 +1610,123 @@ export class AnthropicProvider extends BaseProvider {
                     ...(anthropicToolChoice ? { tool_choice: anthropicToolChoice } : {}),
                     ...(thinking ? { thinking } : {}),
                 };
-                const events = await withProviderRetry(() => client.messages.create(params, {
-                    signal: abortSignal ?? undefined,
-                }), trace.getActiveSpan() ?? undefined, `${this.providerName} stream`);
-                // Per-step accumulators, keyed by content-block index so blocks are
-                // replayed to the conversation in order (thinking blocks must be
-                // passed back with their signatures when tool use continues a turn).
-                const blockTypes = new Map();
-                const textAcc = new Map();
-                const thinkingAcc = new Map();
-                const toolAcc = new Map();
-                let stopReason = null;
-                // message_start carries a small output placeholder and message_delta
-                // reports the CUMULATIVE output for the message — latest wins within
-                // the step (adding both double-counted the placeholder every step).
-                // Write-through: each event folds only the DELTA over this step's
-                // previous value into totalOutput, so the total is correct at every
-                // point mid-drain — a step killed mid-stream (abort/timeout) still
-                // counts the billed output it already reported.
-                let stepOutputTokens = 0;
-                for await (const event of events) {
-                    if (event.type === "message_start") {
-                        totalInput += event.message.usage.input_tokens ?? 0;
-                        const startOutputTokens = event.message.usage.output_tokens ?? 0;
-                        totalOutput += startOutputTokens - stepOutputTokens;
-                        stepOutputTokens = startOutputTokens;
-                        // Anthropic reports cache reads/writes SEPARATELY from
-                        // input_tokens on the same message_start event — without these
-                        // the streaming path silently drops all cache accounting.
-                        totalCacheRead += event.message.usage.cache_read_input_tokens ?? 0;
-                        totalCacheWrite +=
-                            event.message.usage.cache_creation_input_tokens ?? 0;
-                        // Calibration signal for the in-turn guard: the FULL prompt size,
-                        // which on this path means uncached input plus both cache tiers.
-                        // Using input_tokens alone would read a cache-hit step as tiny and
-                        // let the guard drift far under the real cost.
-                        lastObservedPromptTokens =
-                            (event.message.usage.input_tokens ?? 0) +
-                                (event.message.usage.cache_read_input_tokens ?? 0) +
-                                (event.message.usage.cache_creation_input_tokens ?? 0);
-                    }
-                    else if (event.type === "content_block_start") {
-                        blockTypes.set(event.index, event.content_block.type);
-                        if (event.content_block.type === "tool_use") {
-                            toolAcc.set(event.index, {
-                                id: event.content_block.id,
-                                name: event.content_block.name,
-                                inputJson: "",
-                            });
-                        }
-                    }
-                    else if (event.type === "content_block_delta") {
-                        const delta = event.delta;
-                        if (delta.type === "text_delta") {
-                            textAcc.set(event.index, (textAcc.get(event.index) ?? "") + delta.text);
-                            if (finalResultActive) {
-                                bufferedText += delta.text;
-                            }
-                            else {
-                                pushChunk({ content: delta.text });
-                            }
-                        }
-                        else if (delta.type === "thinking_delta") {
-                            const acc = thinkingAcc.get(event.index) ?? {
-                                text: "",
-                                signature: "",
-                            };
-                            acc.text += delta.thinking;
-                            thinkingAcc.set(event.index, acc);
-                            // Reasoning rides the dedicated chunk channel; `content` stays
-                            // an always-present string so plain-text consumers are safe.
-                            pushChunk({ content: "", reasoning: delta.thinking });
-                        }
-                        else if (delta.type === "signature_delta") {
-                            const acc = thinkingAcc.get(event.index) ?? {
-                                text: "",
-                                signature: "",
-                            };
-                            acc.signature += delta.signature;
-                            thinkingAcc.set(event.index, acc);
-                        }
-                        else if (delta.type === "input_json_delta") {
-                            const acc = toolAcc.get(event.index);
-                            if (acc) {
-                                acc.inputJson += delta.partial_json;
-                            }
-                        }
-                    }
-                    else if (event.type === "message_delta") {
-                        stopReason = event.delta.stop_reason ?? stopReason;
-                        const cumulativeOutputTokens = event.usage?.output_tokens ?? stepOutputTokens;
-                        totalOutput += cumulativeOutputTokens - stepOutputTokens;
-                        stepOutputTokens = cumulativeOutputTokens;
-                    }
-                }
-                lastStop = stopReason;
-                // final_result is terminal: its arguments ARE the answer, so the turn
-                // ends here and any tool calls issued alongside it are not executed
-                // (parity with the native Vertex loops). It is never executed as a
-                // tool, never recorded in toolsUsed, and never stored as a tool
-                // execution — the pattern stays invisible to callers.
-                if (finalResultActive) {
-                    const finalCall = [...toolAcc.values()].find((acc) => acc.name === FINAL_RESULT_TOOL_NAME);
-                    if (finalCall) {
-                        finalResultText = stringifyFinalResultInput(finalCall.inputJson);
-                        lastStop = "end_turn";
-                        logger.debug("[Anthropic] Extracted structured output from final_result tool (stream)", { chars: finalResultText.length });
-                        break;
-                    }
-                }
-                if (stopReason !== "tool_use" || toolAcc.size === 0) {
-                    break;
-                }
-                // Replay this assistant turn (thinking + text + tool_use blocks, in
-                // block order) then execute the requested tools and append their
-                // results as a user turn — the native multi-step tool loop.
-                const assistantBlocks = [];
-                const orderedIndexes = [...blockTypes.keys()].sort((a, b) => a - b);
-                for (const idx of orderedIndexes) {
-                    const type = blockTypes.get(idx);
-                    if (type === "thinking") {
-                        const acc = thinkingAcc.get(idx);
-                        if (acc && acc.text.length > 0) {
-                            assistantBlocks.push({
-                                type: "thinking",
-                                thinking: acc.text,
-                                signature: acc.signature,
-                            });
-                        }
-                    }
-                    else if (type === "text") {
-                        const text = textAcc.get(idx);
-                        if (text && text.length > 0) {
-                            assistantBlocks.push({ type: "text", text });
-                        }
-                    }
-                    else if (type === "tool_use") {
-                        const acc = toolAcc.get(idx);
-                        if (acc) {
-                            let input;
-                            try {
-                                input = acc.inputJson ? JSON.parse(acc.inputJson) : {};
-                            }
-                            catch {
-                                input = {};
-                            }
-                            assistantBlocks.push({
-                                type: "tool_use",
-                                id: acc.id,
-                                name: acc.name,
-                                input,
-                            });
-                        }
-                    }
-                }
-                conversation.push({ role: "assistant", content: assistantBlocks });
-                const resultBlocks = [];
-                const toolCallsForStorage = [];
-                const toolResultsForStorage = [];
-                for (const acc of toolAcc.values()) {
-                    let args;
-                    try {
-                        args = acc.inputJson
-                            ? JSON.parse(acc.inputJson)
-                            : {};
+            };
+            const baseAdapter = createAnthropicLoopAdapter({
+                client,
+                maxSteps,
+                toolsRecord,
+                buildParams,
+                planReclaim,
+                noteObservedPromptTokens: (tokens) => {
+                    lastObservedPromptTokens = tokens;
+                },
+                ...(finalResultActive
+                    ? {
+                        finalResultToolName: FINAL_RESULT_TOOL_NAME,
+                        onTerminalResult: (text) => {
+                            finalResultText = text;
+                            logger.debug("[Anthropic] Extracted structured output from final_result tool (stream)", { chars: text.length });
+                        },
                     }
-                    catch {
-                        args = {};
+                    : {}),
+            });
+            // Wrapped rather than folded into the adapter: analytics emission and
+            // tool-execution storage fire ONCE PER STEP in the loop this replaces,
+            // and buildToolResultMessages is the only per-step hook — it receives
+            // exactly that step's results. Doing this from the turn's final result
+            // instead would batch every step's tools into one late write.
+            const adapter = {
+                ...baseAdapter,
+                buildToolResultMessages: (conversation, stepResult, toolResults) => {
+                    for (const result of toolResults) {
+                        toolsUsed.push(result.name);
                     }
-                    toolCallsForStorage.push({
+                    const toolCallsForStorage = toolResults.map((result) => ({
                         type: "tool-call",
-                        toolCallId: acc.id,
-                        toolName: acc.name,
-                        args,
-                    });
-                    toolsUsed.push(acc.name);
-                    // Live record lookup, then deferred-catalog auto-hydration: with
-                    // tools.discovery on, the model may call a cataloged tool it never
-                    // loaded via search_tools — a real tool, not a hallucination.
-                    const tool = (toolsRecord[acc.name] ??
-                        resolveDeferredTool(toolsRecord, acc.name));
-                    try {
-                        if (!tool?.execute) {
-                            throw new Error(`Tool not found: ${acc.name}`);
+                        toolCallId: result.id,
+                        toolName: result.name,
+                        args: result.args,
+                    }));
+                    const toolResultsForStorage = toolResults.map((result) => result.error
+                        ? {
+                            type: "tool-result",
+                            toolCallId: result.id,
+                            toolName: result.name,
+                            error: result.error,
                         }
-                        const result = await tool.execute(args, {
-                            toolCallId: acc.id,
-                            messages: [],
-                        });
-                        toolResultsForStorage.push({
+                        : {
                             type: "tool-result",
-                            toolCallId: acc.id,
-                            toolName: acc.name,
-                            result,
-                        });
-                        resultBlocks.push({
-                            type: "tool_result",
-                            tool_use_id: acc.id,
-                            content: stringifyAnthropicToolOutput(result),
+                            toolCallId: result.id,
+                            toolName: result.name,
+                            result: result.output,
                         });
-                    }
-                    catch (toolErr) {
-                        const message = toolErr instanceof Error ? toolErr.message : String(toolErr);
-                        toolResultsForStorage.push({
-                            type: "tool-result",
-                            toolCallId: acc.id,
-                            toolName: acc.name,
-                            error: message,
+                    emitToolEndFromStepFinish(emitter, toolResultsForStorage.map((tr) => ({
+                        toolName: tr.toolName,
+                        result: "result" in tr ? tr.result : undefined,
+                        error: "error" in tr ? tr.error : undefined,
+                    })));
+                    this.handleToolExecutionStorage(toolCallsForStorage, toolResultsForStorage, options, new Date()).catch((storageErr) => {
+                        logger.warn("[AnthropicProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: storageErr instanceof Error
+                                ? storageErr.message
+                                : String(storageErr),
                         });
-                        resultBlocks.push({
-                            type: "tool_result",
-                            tool_use_id: acc.id,
-                            content: `Error: ${message}`,
-                            is_error: true,
+                    });
+                    return baseAdapter.buildToolResultMessages(conversation, stepResult, toolResults);
+                },
+            };
+            // Presented in the shape the engine dispatches through. The engine
+            // supplies `{ toolCallId, abortSignal }`; the loop this replaces also
+            // supplied `messages: []`, so it is kept — a tool that reads it would
+            // otherwise see undefined where it used to see an empty array.
+            const engineTools = {};
+            for (const [name, tool] of Object.entries(toolsRecord)) {
+                const execute = tool.execute;
+                if (!execute) {
+                    continue;
+                }
+                engineTools[name] = {
+                    execute: async (args, opts) => {
+                        const ctx = opts;
+                        return execute(args, {
+                            toolCallId: ctx.toolCallId ?? "",
+                            ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}),
+                            messages: [],
                         });
+                    },
+                };
+            }
+            const { stream, resultPromise } = runAgenticLoop(adapter, payload.messages.slice(), {
+                tools: engineTools,
+                ...(abortSignal ? { abortSignal } : {}),
+            });
+            // Structured turns buffer their text rather than streaming it: a caller
+            // that passed a schema needs parseable JSON, and deltas emitted before
+            // the model calls final_result would prefix the payload with prose.
+            // Reasoning is forwarded either way — it is not part of the payload.
+            const pump = (async () => {
+                for await (const chunk of stream) {
+                    if (chunk.reasoning) {
+                        pushChunk({ content: "", reasoning: chunk.reasoning });
+                    }
+                    if (chunk.content) {
+                        if (finalResultActive) {
+                            bufferedText += chunk.content;
+                        }
+                        else {
+                            pushChunk({ content: chunk.content });
+                        }
                     }
                 }
-                // Emit tool:end events for Pipeline B and persist tool executions —
-                // the same hooks the streamText onStepFinish callback used to drive.
-                emitToolEndFromStepFinish(emitter, toolResultsForStorage.map((tr) => ({
-                    toolName: tr.toolName,
-                    result: tr.result,
-                    error: tr.error,
-                })));
-                this.handleToolExecutionStorage(toolCallsForStorage, toolResultsForStorage, options, new Date()).catch((storageErr) => {
-                    logger.warn("[AnthropicProvider] Failed to store tool executions", {
-                        provider: this.providerName,
-                        error: storageErr instanceof Error
-                            ? storageErr.message
-                            : String(storageErr),
-                    });
-                });
-                conversation.push({ role: "user", content: resultBlocks });
-            }
+            })();
+            const result = await resultPromise;
+            await pump;
+            totalInput += result.usage.inputTokens;
+            totalOutput += result.usage.outputTokens;
+            totalCacheRead += result.usage.cacheReadTokens ?? 0;
+            totalCacheWrite += result.usage.cacheWriteTokens ?? 0;
+            lastStop = result.rawStopReason ?? lastStop;
             resolveUsage(buildDeferredUsage());
             resolveFinish(lastStop ?? "stop");
         };

package/dist/lib/providers/anthropic/loopAdapter.js

@@ -285,6 +285,9 @@ export function createAnthropicLoopAdapter(config) {
             const finalText = terminal
                 ? stringifyFinalResultInput(terminal.inputJson)
                 : text;
+            if (terminal) {
+                config.onTerminalResult?.(finalText);
+            }
             return {
                 text: finalText,
                 ...(reasoning ? { reasoning } : {}),

package/dist/lib/providers/googleAiStudio/client.js

@@ -1001,7 +1001,16 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 if (wantsNativeJsonRequested && exclusionInForce) {
                     logger.warn("[GoogleAIStudio] Gemini does not support tools and JSON schema output simultaneously. Disabling tools for this request (generate()).");
                 }
-                if (shouldUseTools && !exclusionInForce) {
+                // Both conjuncts, matching the warning directly above and the
+                // stream path's gate. `isToolsSchemaExclusionInForce` answers "does
+                // the tools/schema exclusion APPLY to this provider and model", and
+                // is true for any Gemini request that has tools at all — it is not
+                // "the exclusion is triggered". Testing `!exclusionInForce` alone
+                // therefore made this branch reachable only when there were NO
+                // tools, so every caller-supplied tool was dropped on the generate
+                // path whether or not structured output was ever requested.
+                if (shouldUseTools &&
+                    !(wantsNativeJsonRequested && exclusionInForce)) {
                     const tools = options.tools || {};
                     if (Object.keys(tools).length > 0) {
                         const result = toNativeToolDeclarations(tools, "functionDeclarations");

package/dist/lib/types/loopEngine.d.ts

@@ -151,6 +151,18 @@ export type AnthropicLoopAdapterConfig = {
      * ordinary zero-tool-calls exit.
      */
     finalResultToolName?: string;
+    /**
+     * Called with the terminal tool's payload when one was actually detected.
+     *
+     * The caller cannot infer this from the turn's result. A structured turn
+     * ends with the payload in `text` when the model called the terminal tool,
+     * and with ordinary prose in `text` when it ignored the instruction and
+     * answered directly — the two are indistinguishable downstream, yet they
+     * are handled differently: the payload is delivered as the answer, while
+     * prose is delivered from the caller's own buffer. Comparing strings to
+     * tell them apart would be guesswork, so the adapter says which happened.
+     */
+    onTerminalResult?: (text: string) => void;
     toolFailureBreaker?: AgenticLoopToolFailureBreaker;
     /**
      * In-turn context reclaim, run once per step before the request is built.