@juspay/neurolink 12.47.13 → 12.48.0

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());
         }
@@ -2393,7 +2394,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 contents: [text],
             });
             const embedding = result.embeddings?.[0]?.values;
-            if (!embedding) {
+            if (!embedding || embedding.length === 0) {
                 throw new ProviderError("No embedding returned from Google AI", this.providerName);
             }
             logger.debug("Embedding generated successfully", {
@@ -2425,10 +2426,11 @@ export class GoogleAIStudioProvider extends BaseProvider {
             model: embeddingModelName,
             count: texts.length,
         });
+        let rows;
         try {
             const apiKey = this.getApiKey();
             const client = await createGoogleGenAIClient(apiKey, this.getBaseURL());
-            const embeddings = [];
+            rows = [];
             if (embeddingModelName.includes("gemini-embedding-2")) {
                 // @google/genai 2.x reads an array of strings for these models as ONE
                 // content with several parts, so a batch would come back as a single
@@ -2441,7 +2443,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         contents: [text],
                     })));
                     for (const result of results) {
-                        embeddings.push(result.embeddings?.[0]?.values || []);
+                        rows.push(result.embeddings?.[0]?.values);
                     }
                 }
             }
@@ -2450,20 +2452,13 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     model: embeddingModelName,
                     contents: texts,
                 });
-                embeddings.push(...(result.embeddings || []).map((e) => e.values || []));
+                rows.push(...(result.embeddings || []).map((e) => e.values));
             }
             // One vector per text, or fail: a silent mismatch would pair texts with
             // the wrong vectors downstream.
-            if (embeddings.length !== texts.length) {
-                throw new Error(`Embedding response held ${embeddings.length} vectors for ${texts.length} texts`);
+            if (rows.length !== texts.length) {
+                throw new Error(`Embedding response held ${rows.length} vectors for ${texts.length} texts`);
             }
-            logger.debug("Batch embeddings generated successfully", {
-                provider: this.providerName,
-                model: embeddingModelName,
-                count: embeddings.length,
-                embeddingDimension: embeddings[0]?.length,
-            });
-            return embeddings;
         }
         catch (error) {
             logger.error("Batch embedding generation failed", {
@@ -2473,6 +2468,26 @@ export class GoogleAIStudioProvider extends BaseProvider {
             });
             throw this.handleProviderError(error);
         }
+        // Checked after the try on purpose: a thrown error is re-worded by
+        // handleProviderError from keywords in its text, so an index such as 429
+        // or 502 would turn this into a rate-limit or server error.
+        const embeddings = rows.map((values, index) => {
+            if (!values || values.length === 0) {
+                logger.error("Batch embedding returned no values", {
+                    model: embeddingModelName,
+                    index,
+                });
+                throw new ProviderError(`Embedding for the text at index ${index} came back without values`, this.providerName);
+            }
+            return values;
+        });
+        logger.debug("Batch embeddings generated successfully", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            count: embeddings.length,
+            embeddingDimension: embeddings[0]?.length,
+        });
+        return embeddings;
     }
     getApiKey() {
         const apiKey = this.credentials?.apiKey ||