@juspay/neurolink 12.47.14 → 12.48.1

package/dist/providers/amazonBedrock/client.js

@@ -210,6 +210,10 @@ export class AmazonBedrockProvider extends BaseProvider {
             });
             // Cast options to StreamOptions for multimodal processing
             const streamOptions = options;
+            // This provider bypasses BaseProvider's message builders, so the
+            // instance-level `conversationMemory.replayToolSteps` has to be folded
+            // in here or only the per-request value would ever apply.
+            this.applyToolReplayDefault(streamOptions);
             const multimodalOptions = buildMultimodalOptions(streamOptions, this.providerName, this.modelName);
             const multimodalMessages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
             // Convert to Bedrock format
@@ -923,6 +927,8 @@ export class AmazonBedrockProvider extends BaseProvider {
                         hasPDFFiles: !!options.input?.pdfFiles?.length,
                         pdfFileCount: options.input?.pdfFiles?.length || 0,
                     });
+                    // Same instance-default fold as the generate() path above.
+                    this.applyToolReplayDefault(options);
                     const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
                     const multimodalMessages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
                     // Convert to Bedrock format

package/dist/providers/amazonSagemaker.js

@@ -6,6 +6,7 @@ import { resolveToolExecutionRecords, toolCallsFromSummaries, } from "../core/to
 import { transformToolExecutions } from "../utils/transformationUtils.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { withProviderRetry } from "../utils/providerRetry.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { hasNativeDoGenerate, runNativeGenerateLoop, } from "../core/nativeGenerateLoop.js";
 import { withSpan } from "../telemetry/withSpan.js";
@@ -233,6 +234,17 @@ export class AmazonSageMakerProvider extends BaseProvider {
             ...(responseFormat ? { responseFormat } : {}),
             ...(v3Tools.length > 0 ? { tools: v3Tools } : {}),
             toolsRecord,
+            // Was never forwarded here, so a caller's toolChoice degraded to the
+            // endpoint's default on SageMaker alone; the language model already
+            // maps it onto `tool_choice`.
+            ...(v3Tools.length > 0 && options.toolChoice
+                ? { toolChoice: resolveToolChoice(options, toolsRecord, true) }
+                : {}),
+            ...(options.toolChoiceSteps !== undefined
+                ? { toolChoiceSteps: options.toolChoiceSteps }
+                : {}),
+            ...(options.prepareStep ? { prepareStep: options.prepareStep } : {}),
+            modelId: this.modelName,
             maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
             ...(options.maxTokens ? { maxOutputTokens: options.maxTokens } : {}),
             ...(options.temperature !== undefined
@@ -245,6 +257,7 @@ export class AmazonSageMakerProvider extends BaseProvider {
             runStep: (call) => withProviderRetry(call, undefined, "sagemaker generate", undefined, options.abortSignal).catch((err) => {
                 throw this.handleProviderError(err);
             }),
+            onRejectedToolCall: (name, error, id) => this.emitRejectedToolCall(name, error, id),
         }, toolExecutionSummaries);
         const enhanced = {
             content: loop.text,
@@ -263,7 +276,7 @@ export class AmazonSageMakerProvider extends BaseProvider {
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),
             enhancedWithTools: loop.toolsUsed.length > 0,
         };
-        return this.finalizeNativeGenerate(enhanced, options, startTime);
+        return this.finalizeNativeGenerate(enhanced, options, startTime, toolExecutionSummaries);
     }
     /**
      * Streaming was previously an `executeStream` override that unconditionally

package/dist/providers/anthropic/client.js

@@ -26,7 +26,7 @@ import { stringifyAnthropicToolOutput } from "./toolOutput.js";
 import { createAnthropicLoopAdapter } from "./loopAdapter.js";
 import { DEFAULT_BEFORE_STEP_TIMEOUT_MS } from "../../utils/parameterValidation.js";
 import { runAgenticLoop } from "../../core/loopEngine.js";
-import { hasNativeDoGenerate, runNativeGenerateLoop, } from "../../core/nativeGenerateLoop.js";
+import { hasNativeDoGenerate, resolveStepToolChoice, runNativeGenerateLoop, toPrepareStepRecord, } from "../../core/nativeGenerateLoop.js";
 import { withProviderRetry } from "../../utils/providerRetry.js";
 import { resolveRequestKind } from "../../core/resolveRequestKind.js";
 import { resolveToolExecutionRecords, toolCallsFromSummaries, } from "../../core/toolExecutionRecorder.js";
@@ -35,7 +35,6 @@ import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../../
 import { composeAbortSignals, composeAbortSignalsScoped, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../../utils/timeout.js";
 import { raceWithAbort } from "../../utils/async/index.js";
 import { normalizeResolvedToolChoice, resolveToolChoice, } from "../../utils/toolChoice.js";
-import { emitToolEndFromStepFinish } from "../../utils/toolEndEmitter.js";
 import { NoOutputGeneratedError } from "../../utils/generationErrors.js";
 import { buildNoOutputSentinel, stampNoOutputSpan, } from "../../utils/noOutputSentinel.js";
 import { convertZodToJsonSchema } from "../../utils/schemaConversion.js";
@@ -1613,6 +1612,11 @@ export class AnthropicProvider extends BaseProvider {
             ...(hasTools && options.toolChoice
                 ? { toolChoice: resolveToolChoice(options, toolsRecord, true) }
                 : {}),
+            ...(options.toolChoiceSteps !== undefined
+                ? { toolChoiceSteps: options.toolChoiceSteps }
+                : {}),
+            ...(options.prepareStep ? { prepareStep: options.prepareStep } : {}),
+            modelId,
             ...(responseFormat ? { responseFormat } : {}),
             ...(providerOptions ? { providerOptions } : {}),
             maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
@@ -1627,6 +1631,7 @@ export class AnthropicProvider extends BaseProvider {
             runStep: (call) => withProviderRetry(call, trace.getActiveSpan() ?? undefined, "anthropic generate", undefined, options.abortSignal).catch((err) => {
                 throw this.handleProviderError(err);
             }),
+            onRejectedToolCall: (name, error, id) => this.emitRejectedToolCall(name, error, id),
         }, toolExecutionSummaries);
         const enhanced = {
             content: loop.text,
@@ -1660,7 +1665,7 @@ export class AnthropicProvider extends BaseProvider {
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),
             enhancedWithTools: loop.toolsUsed.length > 0,
         };
-        return this.finalizeNativeGenerate(enhanced, options, startTime);
+        return this.finalizeNativeGenerate(enhanced, options, startTime, toolExecutionSummaries);
     }
     /**
      * Fold a captured snapshot into the provider's usage bookkeeping and log it.
@@ -1748,6 +1753,11 @@ export class AnthropicProvider extends BaseProvider {
             // options.tools is pre-merged by BaseProvider.stream() with base tools
             // (MCP/built-in) + user-provided tools (RAG, etc.)
             shouldUseTools = !options.disableTools && this.supportsTools();
+            // Used as is: BaseProvider.stream() already event-wrapped, recorder-
+            // wrapped and discovery-partitioned this record, and search_tools
+            // hydrates new tools into THIS object mid-turn. A copy would lose the
+            // null prototype, the non-enumerable resolver and every later
+            // hydration, so a discovered tool the model then called was "not found".
             toolsRecord = shouldUseTools
                 ? options.tools || (await this.getAllTools())
                 : {};
@@ -1776,9 +1786,17 @@ export class AnthropicProvider extends BaseProvider {
             throw this.handleProviderError(setupErr);
         }
         const modelId = this.modelName || getDefaultAnthropicModel();
-        const anthropicToolChoice = shouldUseTools && anthropicTools && anthropicTools.length > 0
-            ? relaxForcedToolChoice(modelId, toolChoiceToAnthropic(resolveToolChoice(options, toolsRecord, shouldUseTools)))
+        // The turn's choice in NeuroLink shape. Translated to the wire PER STEP
+        // inside buildParams, because a forced choice applies only to the first
+        // `toolChoiceSteps` steps — baked in once, it compelled a tool call on
+        // every step and the turn ran until maxSteps.
+        const turnToolChoice = shouldUseTools && anthropicTools && anthropicTools.length > 0
+            ? resolveToolChoice(options, toolsRecord, shouldUseTools)
             : undefined;
+        // Completed-step records handed to a caller's prepareStep hook. Filled by
+        // the buildToolResultMessages wrapper below, which is the only per-step
+        // hook that sees a step's calls and results together.
+        const stepRecords = [];
         // Extended thinking: enabled when the caller supplies an explicit token
         // budget (mirrors the previous experimental_thinking gating). Thinking
         // deltas stream out on the `reasoning` chunk channel.
@@ -1803,7 +1821,6 @@ export class AnthropicProvider extends BaseProvider {
             },
         });
         const maxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
-        const emitter = this.neurolink?.getEventEmitter();
         const channel = createStreamChannel();
         const { push: pushChunk } = channel;
         const { usagePromise, finishPromise, resolveUsage, resolveFinish } = createDeferredAnalytics();
@@ -1842,7 +1859,15 @@ export class AnthropicProvider extends BaseProvider {
         });
         let capturedProviderError;
         const client = this.client;
+        // Every attempted call, for the no-output sentinel below; the result
+        // reports only calls that returned a value, the rule the generate loop
+        // and Bedrock already follow.
         const toolsUsed = [];
+        const toolsSucceeded = [];
+        // Every tool this turn ran, in the loop's own summary shape. Backs the
+        // result's toolCalls / toolResults / toolExecutions getters, which read it
+        // live so a consumer that drains the stream first sees the full turn.
+        const streamToolSummaries = [];
         const streamStartTime = Date.now();
         // Mutable-reference contract from StreamResult.metadata: created before
         // the loop and filled once the turn drains, because wrapper spreads
@@ -1965,7 +1990,27 @@ export class AnthropicProvider extends BaseProvider {
                 }
                 return { conversation: rebuilt };
             };
-            const buildParams = (conversation) => {
+            const buildParams = async (conversation, step) => {
+                // Consulted whenever there is a base choice OR a hook: a hook with
+                // no base choice still gets to force a tool on a given step.
+                // No declared tools → no tool_choice and no hook call; Anthropic
+                // rejects a tool_choice on a request without tools.
+                const anthropicToolChoice = (turnToolChoice !== undefined || options.prepareStep) &&
+                    anthropicTools &&
+                    anthropicTools.length > 0
+                    ? // Per step, so a prepareStep-forced choice gets the same
+                        // Claude 5.5/5.1 relaxation as the turn's base choice.
+                        relaxForcedToolChoice(modelId, toolChoiceToAnthropic(await resolveStepToolChoice({
+                            base: turnToolChoice,
+                            step,
+                            toolChoiceSteps: options.toolChoiceSteps,
+                            prepareStep: options.prepareStep,
+                            steps: stepRecords,
+                            maxSteps,
+                            model: modelId,
+                            ...(abortSignal ? { abortSignal } : {}),
+                        })))
+                    : undefined;
                 // 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.
@@ -2055,33 +2100,77 @@ export class AnthropicProvider extends BaseProvider {
             const adapter = {
                 ...baseAdapter,
                 buildToolResultMessages: (conversation, stepResult, toolResults, engineStep) => {
+                    const settledAt = new Date();
                     for (const result of toolResults) {
                         toolsUsed.push(result.name);
+                        if (!result.error) {
+                            toolsSucceeded.push(result.name);
+                        }
+                        streamToolSummaries.push({
+                            toolCallId: result.id,
+                            toolName: result.name,
+                            input: result.args,
+                            ...(result.error
+                                ? { error: result.error }
+                                : { output: result.output }),
+                            // The engine reports a step's results together, after the
+                            // batch has settled, so per-tool timing is not available here;
+                            // `toolExecutions` prefers the execution recorder's own records,
+                            // which do carry it.
+                            startTime: settledAt,
+                            endTime: settledAt,
+                            stepIndex: engineStep,
+                        });
                     }
+                    const rawBlocks = stepResult.raw;
+                    stepRecords.push(toPrepareStepRecord({
+                        stepNumber: engineStep,
+                        content: rawBlocks.map((block) => block),
+                        text: stepResult.text,
+                        toolCalls: stepResult.toolCalls.map((call) => ({
+                            toolName: call.name,
+                            toolCallId: call.id,
+                            input: call.args,
+                        })),
+                        toolResults: toolResults.map((result) => ({
+                            toolName: result.name,
+                            toolCallId: result.id,
+                            output: result.error ? { error: result.error } : result.output,
+                        })),
+                        finishReason: "tool-calls",
+                        inputTokens: stepResult.usage.inputTokens,
+                        outputTokens: stepResult.usage.outputTokens,
+                        ...(stepResult.usage.cacheReadTokens !== undefined ||
+                            stepResult.usage.cacheWriteTokens !== undefined
+                            ? {
+                                cacheReadTokens: stepResult.usage.cacheReadTokens ?? 0,
+                                cacheWriteTokens: stepResult.usage.cacheWriteTokens ?? 0,
+                            }
+                            : {}),
+                    }));
+                    // `tool:start` / `tool:end` are emitted by the executor itself
+                    // (ToolsManager, external MCP, neurolink.executeTool), so nothing is
+                    // emitted here: a second `tool:end` per result — with a zeroed
+                    // responseTime — used to be, and doubled every consumer's count.
                     const toolCallsForStorage = toolResults.map((result) => ({
-                        type: "tool-call",
                         toolCallId: result.id,
                         toolName: result.name,
                         args: result.args,
+                        stepIndex: engineStep,
                     }));
                     const toolResultsForStorage = toolResults.map((result) => result.error
                         ? {
-                            type: "tool-result",
                             toolCallId: result.id,
                             toolName: result.name,
                             error: result.error,
+                            stepIndex: engineStep,
                         }
                         : {
-                            type: "tool-result",
                             toolCallId: result.id,
                             toolName: result.name,
-                            result: result.output,
+                            output: result.output,
+                            stepIndex: engineStep,
                         });
-                    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,
@@ -2344,7 +2433,7 @@ export class AnthropicProvider extends BaseProvider {
                 }
             }
         };
-        return {
+        const result = {
             stream: transformedStream(),
             provider: this.providerName,
             // Cell-3 identity fix: `this.modelName` is the raw, possibly-unset
@@ -2355,8 +2444,14 @@ export class AnthropicProvider extends BaseProvider {
             // build the request. Reporting the raw field previously let a
             // default-model turn's StreamResult claim an undefined/empty model.
             model: modelId,
-            toolCalls: [],
-            toolResults: [],
+            // `toolCalls` / `toolResults` / `toolExecutions` are defined as live
+            // getters below, over the per-turn summaries.
+            // The live array: pushed as steps settle, so a consumer reading after
+            // the drain sees every tool that ran and returned a value (a thrown or
+            // not-found call is not "used"). This was never returned before, so
+            // `toolsUsed` came back empty for every tool on this path and
+            // `enhancedWithTools` was always false.
+            toolsUsed: toolsSucceeded,
             metadata: turnMetadata,
             // Wire the deferred usage/finish promises into the analytics collector
             // (mirrors openaiChatCompletionsBase). Without this the loop computed a
@@ -2384,6 +2479,40 @@ export class AnthropicProvider extends BaseProvider {
                 return analytics;
             }),
         };
+        // Live getters, mirroring openaiChatCompletionsBase: the wrapper layers
+        // (BaseProvider.stream, NeuroLink.stream) re-apply accessor descriptors
+        // rather than spreading values, so these resolve when read, after the
+        // background loop has run the tools — a plain value here would be the
+        // empty snapshot taken before the first chunk.
+        Object.defineProperty(result, "toolCalls", {
+            enumerable: true,
+            configurable: true,
+            get: () => toolCallsFromSummaries(streamToolSummaries),
+        });
+        Object.defineProperty(result, "toolResults", {
+            enumerable: true,
+            configurable: true,
+            get: () => streamToolSummaries.map((s) => ({
+                toolName: s.toolName,
+                id: s.toolCallId,
+                status: s.error ? "failure" : "success",
+                ...(s.error ? { error: s.error } : {}),
+                ...(s.output !== undefined
+                    ? { output: s.output }
+                    : {}),
+            })),
+        });
+        Object.defineProperty(result, "toolExecutions", {
+            enumerable: true,
+            configurable: true,
+            get: () => resolveToolExecutionRecords(options, transformToolExecutions(streamToolSummaries.map((s) => ({
+                toolName: s.toolName,
+                input: s.input,
+                output: s.error ? { error: s.error } : s.output,
+                duration: s.endTime.getTime() - s.startTime.getTime(),
+            })))),
+        });
+        return result;
     }
     async isAvailable() {
         try {

package/dist/providers/anthropic/loopAdapter.js

@@ -382,8 +382,8 @@ export function createAnthropicLoopAdapter(config) {
                 execute: async (args, opts) => execute(args, opts),
             };
         },
-        buildStepRequest(conversation, step) {
-            return { raw: config.buildParams(conversation, step) };
+        async buildStepRequest(conversation, step) {
+            return { raw: await config.buildParams(conversation, step) };
         },
         async executeStep(request, channel, signal) {
             const params = request.raw;

package/dist/providers/googleAiStudio/client.js

@@ -8,6 +8,7 @@ import { ERROR_CODES, NeuroLinkError } from "../../utils/errorHandling.js";
 import { logger } from "../../utils/logger.js";
 import { drainDetachedPump } from "../../utils/drainDetachedPump.js";
 import { createGeminiLoopAdapter } from "../../core/geminiLoopAdapter.js";
+import { isDirectTTSRequest } from "../../core/resolveRequestKind.js";
 import { runAgenticLoop } from "../../core/loopEngine.js";
 import { DEFAULT_TOOL_MAX_RETRIES, resolveToolTimeoutMs, } from "../../core/constants.js";
 import { isToolsSchemaExclusionInForce } from "../../core/modules/structuredOutputPolicy.js";
@@ -2043,7 +2044,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
         // TTS direct-synthesis mode: synthesise the input text directly (no LLM
         // call). BaseProvider.runGenerateInActiveContext does the same dispatch
         // — replicated here because AI Studio's override bypasses that path.
-        if (options.tts?.enabled && !options.tts?.useAiResponse) {
+        if (isDirectTTSRequest(options.tts)) {
             logger.info("[GoogleAIStudio] Routing TTS direct-synthesis to handleDirectTTSSynthesis", { model: modelName });
             return this.handleDirectTTSSynthesis(options, Date.now());
         }

package/dist/providers/openaiChatCompletionsBase.js

@@ -33,9 +33,8 @@ import { redactUrlCredentials } from "../utils/logSanitize.js";
 import { NoOutputGeneratedError } from "../utils/generationErrors.js";
 import { buildNoOutputSentinel, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
 import { composeAbortSignalsScoped, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../utils/timeout.js";
-import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { resolveRequestKind } from "../core/resolveRequestKind.js";
-import { appendJsonSchemaInstruction, hasNativeDoGenerate, runNativeGenerateLoop, } from "../core/nativeGenerateLoop.js";
+import { appendJsonSchemaInstruction, hasNativeDoGenerate, resolveStepToolChoice, runNativeGenerateLoop, toPrepareStepRecord, } from "../core/nativeGenerateLoop.js";
 import { resolveToolExecutionRecords, toolCallsFromSummaries, } from "../core/toolExecutionRecorder.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { coerceJsonToSchema, recoverScalarRoot, schemaAccepts, } from "../utils/json/coerce.js";
@@ -908,6 +907,11 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         }
         const doGenerate = model.doGenerate.bind(model);
         const shouldUseTools = !options.disableTools && this.supportsTools();
+        // `options.tools` arrives from BaseProvider's merge (getToolsForStream)
+        // already event-wrapped, recorder-wrapped and discovery-partitioned. It
+        // must be used AS IS: copying it would drop the discovery record's null
+        // prototype and non-enumerable resolver, and tools search_tools hydrates
+        // later land only in the original object.
         const toolsRecord = shouldUseTools
             ? options.tools || (await this.getAllTools())
             : {};
@@ -979,6 +983,11 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 ...(withTools && hasTools && options.toolChoice
                     ? { toolChoice: resolveToolChoice(options, toolsRecord, true) }
                     : {}),
+                ...(options.toolChoiceSteps !== undefined
+                    ? { toolChoiceSteps: options.toolChoiceSteps }
+                    : {}),
+                ...(options.prepareStep ? { prepareStep: options.prepareStep } : {}),
+                modelId,
                 // The per-call `timeout` keeps its per-MODEL-CALL meaning once
                 // `turnTimeoutMs` owns the whole-turn deadline, and it reaches the
                 // model layer only through this channel. Without it each step fell
@@ -1008,6 +1017,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 runStep: (call) => withProviderRetry(call, trace.getActiveSpan() ?? undefined, `${this.providerName} generate`, undefined, options.abortSignal).catch((err) => {
                     throw this.handleProviderError(err);
                 }),
+                onRejectedToolCall: (name, error, id) => this.emitRejectedToolCall(name, error, id),
             }, toolExecutionSummaries);
         };
         // Structured output rides `response_format` first. When a vendor rejects
@@ -1138,7 +1148,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),
             enhancedWithTools: toolsUsed.length > 0,
         };
-        return this.finalizeNativeGenerate(enhanced, options, startTime);
+        return this.finalizeNativeGenerate(enhanced, options, startTime, toolExecutionSummaries);
     }
     /**
      * Recover structured output on a turn where tools forced `response_format`
@@ -1454,6 +1464,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 doGenerate,
                 conversation: conv,
                 toolsRecord: {},
+                modelId,
                 ...(format ? { responseFormat: format } : {}),
                 maxSteps: 1,
                 ...(options.maxTokens
@@ -1575,7 +1586,10 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         let toolsRecord;
         let wireNameMaps;
         let openAITools;
-        let openAIToolChoice;
+        // The turn's tool choice in NeuroLink shape; translated to the wire per
+        // step (see stepToolChoice below) so a forced choice can lapse after
+        // `toolChoiceSteps` instead of compelling a tool call on every step.
+        let turnToolChoice;
         // The prompt is kept in its pre-wire shape. Model middleware transforms
         // `params.prompt`, and the conversion to the chat-completions wire format
         // has to happen AFTER that or the transform would be discarded.
@@ -1583,6 +1597,8 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         try {
             modelId = await this.resolveModelName();
             const shouldUseTools = !options.disableTools && this.supportsTools();
+            // Same identity rule as executeNativeGenerate: the merged record is
+            // the discovery hot record and is never copied here.
             toolsRecord = shouldUseTools
                 ? options.tools || (await this.getAllTools())
                 : {};
@@ -1594,7 +1610,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             openAITools = shouldUseTools
                 ? buildToolsForOpenAI(toolsRecord, wireNameMaps?.toWire)
                 : undefined;
-            openAIToolChoice = mapNeuroLinkToolChoice(resolveToolChoice(options, toolsRecord, shouldUseTools), wireNameMaps?.toWire);
+            turnToolChoice = resolveToolChoice(options, toolsRecord, shouldUseTools);
             promptMessages = (await this.buildMessagesForStream(options));
         }
         catch (setupErr) {
@@ -1621,7 +1637,6 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         const url = this.getChatCompletionsURL(modelId);
         const fetchImpl = createProxyFetch();
         const maxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
-        const emitter = this.neurolink?.getEventEmitter();
         const toolsUsed = [];
         const toolExecutionSummaries = [];
         const { usagePromise, finishPromise, resolveUsage, resolveFinish } = createDeferredAnalytics();
@@ -1715,10 +1730,22 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     options: sampled,
                     conversation,
                     openAITools,
-                    openAIToolChoice,
+                    // No declared tools → no tool_choice, and the hook is not consulted:
+                    // a forced choice on a tool-less request is a 400.
+                    stepToolChoice: async (step, steps) => openAITools && openAITools.length > 0
+                        ? mapNeuroLinkToolChoice(await resolveStepToolChoice({
+                            base: turnToolChoice,
+                            step,
+                            toolChoiceSteps: options.toolChoiceSteps,
+                            prepareStep: options.prepareStep,
+                            steps,
+                            maxSteps,
+                            model: modelId,
+                            ...(abortSignal ? { abortSignal } : {}),
+                        }), wireNameMaps?.toWire)
+                        : undefined,
                     toolsRecord,
                     toolNameFromWire: wireNameMaps?.fromWire,
-                    emitter,
                     toolsUsed,
                     toolExecutionSummaries,
                     pushChunk: channel.push,
@@ -2012,7 +2039,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         return result;
     }
     async runStreamLoop(args) {
-        const { maxSteps, modelId, url, fetchImpl, abortSignal, options, conversation, openAITools, openAIToolChoice, toolsRecord, toolNameFromWire, emitter, toolsUsed, toolExecutionSummaries, pushChunk, closeChannel, resolveUsage, resolveFinish, responseFormat, onModelObserved, } = args;
+        const { maxSteps, modelId, url, fetchImpl, abortSignal, options, conversation, openAITools, stepToolChoice, toolsRecord, toolNameFromWire, toolsUsed, toolExecutionSummaries, pushChunk, closeChannel, resolveUsage, resolveFinish, responseFormat, onModelObserved, } = args;
         // Hoisted above the try so the catch can resolve the usage accumulated
         // by steps that completed BEFORE the failure — those steps were billed.
         let stepFinish = null;
@@ -2049,7 +2076,10 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             // two different payloads would be meaningless.
             let lastObservedPromptTokens;
             let lastSentEstimate;
+            // Completed-step records handed to a caller's prepareStep hook.
+            const stepRecords = [];
             for (let step = 0; step < maxSteps; step++) {
+                const openAIToolChoice = await stepToolChoice(step, stepRecords);
                 // Mid-turn discovery sync: search_tools (tools.discovery) hydrates
                 // new tools into toolsRecord between steps. Dispatch already re-reads
                 // the record — this block makes the request DECLARE them so the model
@@ -2137,11 +2167,54 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     conversation,
                     toolsRecord,
                     toolNameFromWire: effectiveToolNameFromWire,
-                    emitter,
                     toolsUsed,
                     toolExecutionSummaries,
                     options,
+                    stepIndex: step,
                 });
+                const executed = toolExecutionSummaries.slice(-stepResult.toolCalls.size);
+                stepRecords.push(toPrepareStepRecord({
+                    stepNumber: step,
+                    content: [
+                        ...(stepResult.text
+                            ? [{ type: "text", text: stepResult.text }]
+                            : []),
+                        ...executed.map((s) => ({
+                            type: "tool-call",
+                            toolCallId: s.toolCallId,
+                            toolName: s.toolName,
+                            input: s.input,
+                        })),
+                    ],
+                    text: stepResult.text,
+                    toolCalls: executed.map((s) => ({
+                        toolName: s.toolName,
+                        toolCallId: s.toolCallId,
+                        input: s.input,
+                    })),
+                    toolResults: executed.map((s) => ({
+                        toolName: s.toolName,
+                        toolCallId: s.toolCallId,
+                        output: s.output,
+                    })),
+                    finishReason: "tool-calls",
+                    // prompt_tokens already includes cached_tokens; subtract it so
+                    // this agrees with the generate loop's toDeferredUsage, which
+                    // reports the disjoint noCache figure for the same field —
+                    // otherwise a cached step reports cached tokens twice (once
+                    // here, once in cacheReadTokens) and a prepareStep hook that
+                    // budgets on steps[].usage sees different numbers from
+                    // stream() and generate() for the same step.
+                    inputTokens: Math.max(0, (stepResult.usage?.prompt_tokens ?? 0) -
+                        (stepResult.usage?.prompt_tokens_details?.cached_tokens ?? 0)),
+                    outputTokens: stepResult.usage?.completion_tokens ?? 0,
+                    ...(stepResult.usage?.prompt_tokens_details?.cached_tokens !==
+                        undefined
+                        ? {
+                            cacheReadTokens: Math.min(stepResult.usage.prompt_tokens_details.cached_tokens, stepResult.usage.prompt_tokens ?? 0),
+                        }
+                        : {}),
+                }));
             }
             resolveUsage(toDeferredUsage());
             resolveFinish(stepFinish ?? "stop");
@@ -2258,7 +2331,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         });
     }
     async executeToolBatch(args) {
-        const { stepResult, conversation, toolsRecord, toolNameFromWire, emitter, toolsUsed, toolExecutionSummaries, options, } = args;
+        const { stepResult, conversation, toolsRecord, toolNameFromWire, toolsUsed, toolExecutionSummaries, options, stepIndex, } = args;
         const toolCallsForMessage = [];
         for (const [, t] of stepResult.toolCalls) {
             toolCallsForMessage.push({
@@ -2295,14 +2368,14 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             // loaded via search_tools — that's a real tool, not a hallucination.
             const toolDef = toolsRecord[registryName] ??
                 resolveDeferredTool(toolsRecord, registryName);
-            emitter?.emit("tool:start", {
-                toolName: registryName,
-                toolCallId: t.id,
-                input,
-            });
+            // No `tool:start` here either: registered and built-in tools emit their
+            // own start/end pair from the executor that runs them, and this raw
+            // emission made every one of them count twice.
             if (!toolDef || typeof toolDef.execute !== "function") {
                 errorMsg = `Tool '${registryName}' is not registered.`;
                 output = { error: errorMsg };
+                // Rejected before any execute ran, so no executor will report it.
+                this.emitRejectedToolCall(registryName, errorMsg, t.id);
             }
             else {
                 try {
@@ -2323,6 +2396,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 ...(errorMsg ? { error: errorMsg } : {}),
                 startTime: startedAt,
                 endTime: endedAt,
+                stepIndex,
             });
             conversation.push({
                 role: "tool",
@@ -2331,21 +2405,27 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             });
         }
         const justExecuted = toolExecutionSummaries.slice(-stepResult.toolCalls.size);
-        emitToolEndFromStepFinish(emitter, justExecuted.map((s) => ({
-            toolName: s.toolName,
-            output: s.output,
-            ...(s.error ? { error: s.error } : {}),
-        })));
+        // No `tool:end` here: the executor already emitted start/end with the
+        // real duration, and a second emission per result doubled every
+        // consumer's count.
         try {
+            // `args`, not `input`: both stores read `args`, so the previous
+            // `input:` key persisted every tool call with empty arguments.
             await this.handleToolExecutionStorage(justExecuted.map((s) => ({
                 toolCallId: s.toolCallId,
                 toolName: s.toolName,
-                input: s.input,
-                output: s.output,
+                args: s.input !== null &&
+                    typeof s.input === "object" &&
+                    !Array.isArray(s.input)
+                    ? s.input
+                    : {},
+                ...(s.stepIndex !== undefined ? { stepIndex: s.stepIndex } : {}),
             })), justExecuted.map((s) => ({
                 toolCallId: s.toolCallId,
                 toolName: s.toolName,
                 output: s.output,
+                ...(s.error ? { error: s.error } : {}),
+                ...(s.stepIndex !== undefined ? { stepIndex: s.stepIndex } : {}),
             })), options, new Date());
         }
         catch (err) {