@juspay/neurolink 12.49.18 → 12.49.20

package/dist/core/nativeGenerateLoop.d.ts

@@ -28,6 +28,11 @@ import type { NativeGenerateLoopArgs, NativeGenerateLoopResult, StepResult, Step
  * how a caller forces a tool on step 3 only. A hook that returns no
  * `toolChoice` defers to the rule. Nothing else on the hook's result is read.
  *
+ * A forced single-tool choice, from the hook or from the turn, that names a
+ * tool outside `declaredTools` is warned about and not sent. A hook's choice
+ * is then treated as "no override" and the rule decides; the turn's own
+ * choice becomes `"auto"`. Without `declaredTools` nothing is checked.
+ *
  * A hook that THROWS is logged and treated as "no override": the steps
  * already billed are kept and the rule decides. An abort of the turn while
  * the hook is pending is not a hook failure and is re-thrown. The two are

package/dist/core/nativeGenerateLoop.js

@@ -32,6 +32,60 @@ const isForcedToolChoice = (choice) => {
     }
     return false;
 };
+/**
+ * The tool a choice forces by name, when it forces one. Both wire mappers
+ * honour exactly `{ type: "tool", toolName }` with a non-empty name, so
+ * that is the only shape that names a function on the wire.
+ */
+const forcedToolName = (choice) => {
+    if (typeof choice !== "object" || choice === null) {
+        return undefined;
+    }
+    const { type, toolName } = choice;
+    return type === "tool" && typeof toolName === "string" && toolName !== ""
+        ? toolName
+        : undefined;
+};
+/**
+ * The name a choice forces when `declaredTools` is known and lacks it, else
+ * undefined. Own keys only: the live record may have a null prototype or be
+ * keyed by a name such as "constructor".
+ */
+const undeclaredForcedToolName = (choice, declaredTools) => {
+    if (!declaredTools) {
+        return undefined;
+    }
+    const name = forcedToolName(choice);
+    return name !== undefined && !Object.hasOwn(declaredTools, name)
+        ? name
+        : undefined;
+};
+/**
+ * A forced choice for a tool the request does not declare is dropped for the
+ * step rather than sent, so a stale hook or a platform-gated tool degrades
+ * the turn to the model's own choice instead of failing it with a 400.
+ */
+const warnUndeclaredForcedTool = (toolName, step, source) => {
+    logger.warn(source === "prepareStep"
+        ? `prepareStep forced tool "${toolName}" at step ${step}, but the request does not declare it; ignoring the override for this step`
+        : `toolChoice forces tool "${toolName}" at step ${step}, but the request does not declare it; using "auto" for this step`, { toolName, step, source });
+};
+/**
+ * The names this request actually carries, in the record shape
+ * `declaredTools` takes. The loop sends `args.tools`, built once by the
+ * caller; `args.toolsRecord` can hold more (discovery hydrates into it, and
+ * this loop never re-declares), so only `tools` answers "is it offered".
+ * Null prototype: a tool may be named `__proto__` or `constructor`.
+ */
+const declaredToolRecord = (tools) => {
+    const declared = Object.create(null);
+    for (const tool of tools ?? []) {
+        if (typeof tool.name === "string") {
+            declared[tool.name] = true;
+        }
+    }
+    return declared;
+};
 /**
  * `toolChoiceSteps` is a count of leading steps, so anything but a
  * non-negative integer is meaningless. Fall back to the default with a WARN
@@ -127,6 +181,11 @@ const abortReason = (signal) => {
  * how a caller forces a tool on step 3 only. A hook that returns no
  * `toolChoice` defers to the rule. Nothing else on the hook's result is read.
  *
+ * A forced single-tool choice, from the hook or from the turn, that names a
+ * tool outside `declaredTools` is warned about and not sent. A hook's choice
+ * is then treated as "no override" and the rule decides; the turn's own
+ * choice becomes `"auto"`. Without `declaredTools` nothing is checked.
+ *
  * A hook that THROWS is logged and treated as "no override": the steps
  * already billed are kept and the rule decides. An abort of the turn while
  * the hook is pending is not a hook failure and is re-thrown. The two are
@@ -156,16 +215,27 @@ export async function resolveStepToolChoice(input) {
         }
         warnIgnoredPrepareStepFields(prepared);
         if (prepared?.toolChoice !== undefined) {
-            return prepared.toolChoice;
+            const undeclaredPrepared = undeclaredForcedToolName(prepared.toolChoice, input.declaredTools);
+            if (undeclaredPrepared === undefined) {
+                return prepared.toolChoice;
+            }
+            warnUndeclaredForcedTool(undeclaredPrepared, input.step, "prepareStep");
         }
     }
     if (input.base === undefined) {
         return undefined;
     }
-    if (!isForcedToolChoice(input.base) ||
-        input.step < normalizeToolChoiceSteps(input.toolChoiceSteps)) {
+    if (!isForcedToolChoice(input.base)) {
+        return input.base;
+    }
+    if (input.step >= normalizeToolChoiceSteps(input.toolChoiceSteps)) {
+        return "auto";
+    }
+    const undeclaredBase = undeclaredForcedToolName(input.base, input.declaredTools);
+    if (undeclaredBase === undefined) {
         return input.base;
     }
+    warnUndeclaredForcedTool(undeclaredBase, input.step, "base");
     return "auto";
 }
 /**
@@ -356,6 +426,7 @@ export async function runNativeGenerateLoop(args, toolExecutionSummaries) {
                 steps: stepRecords,
                 maxSteps: args.maxSteps,
                 model: args.modelId,
+                declaredTools: declaredToolRecord(args.tools),
                 ...(args.abortSignal ? { abortSignal: args.abortSignal } : {}),
             })
             : undefined;

package/dist/neurolink.d.ts

@@ -66,6 +66,8 @@ export declare class NeuroLink {
     private mcpSkipped;
     private mcpInitPromise;
     private emitter;
+    /** Request ownership for conversation capture; unscoped emitter events are ignored. */
+    private readonly conversationEventContext;
     /**
      * Process-unique id used to attribute this instance's log events. The SDK
      * entry points run their bodies inside `logger.runInInstanceScope(this.logInstanceId, …)`,
@@ -1047,6 +1049,7 @@ export declare class NeuroLink {
      */
     private generateTextInternal;
     private executeGenerateTextInternalWithSpan;
+    private executeGenerateTextInternalInEventScope;
     private initializeGenerateTextInternalContext;
     private runGenerateTextInternalFlow;
     private captureOriginalConversationMessagesForRecovery;
@@ -1196,6 +1199,8 @@ export declare class NeuroLink {
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
     stream(options: StreamOptions | DynamicOptions): Promise<StreamResult>;
+    /** Re-enter request ownership when the caller drives a deferred async iterator. */
+    private bindConversationEventStream;
     /**
      * Body of {@link stream}, always entered through the instance log scope.
      *

package/dist/neurolink.js

@@ -370,6 +370,8 @@ export class NeuroLink {
     mcpSkipped = false;
     mcpInitPromise = null;
     emitter = createTypedEmitter();
+    /** Request ownership for conversation capture; unscoped emitter events are ignored. */
+    conversationEventContext = new AsyncLocalStorage();
     /**
      * Process-unique id used to attribute this instance's log events. The SDK
      * entry points run their bodies inside `logger.runInInstanceScope(this.logInstanceId, …)`,
@@ -4724,6 +4726,7 @@ Current user's request: ${currentInput}`;
             stallTimeoutMs: options.stallTimeoutMs,
             wrapupTimeLeadMs: options.wrapupTimeLeadMs,
             toolTimeoutMs: options.toolTimeoutMs,
+            toolExecutionCapture: options.toolExecutionCapture,
             abortSignal: options.abortSignal,
             skipToolPromptInjection: options.skipToolPromptInjection,
             middleware: options.middleware,
@@ -4946,7 +4949,7 @@ Current user's request: ${currentInput}`;
             responseTime: textResult.responseTime,
             toolsUsed: textResult.toolsUsed,
             toolCalls: textResult.toolCalls ?? [],
-            toolExecutions: toToolExecutionRecords(textResult.toolExecutions),
+            toolExecutions: toToolExecutionRecords(textResult.toolExecutions, options.toolExecutionCapture),
             enhancedWithTools: textResult.enhancedWithTools,
             availableTools: transformAvailableTools(textResult.availableTools),
             analytics: textResult.analytics,
@@ -5483,8 +5486,15 @@ Current user's request: ${currentInput}`;
         return tracers.sdk.startActiveSpan("neurolink.generateTextInternal", { kind: SpanKind.INTERNAL }, (internalSpan) => this.executeGenerateTextInternalWithSpan(options, internalSpan));
     }
     async executeGenerateTextInternalWithSpan(options, internalSpan) {
+        return this.conversationEventContext.run(Symbol("generate-conversation"), () => this.executeGenerateTextInternalInEventScope(options, internalSpan));
+    }
+    async executeGenerateTextInternalInEventScope(options, internalSpan) {
+        const { eventSequence, cleanup } = this.setupStreamEventListeners();
         try {
-            const context = this.initializeGenerateTextInternalContext(options);
+            const context = {
+                ...this.initializeGenerateTextInternalContext(options),
+                eventSequence,
+            };
             internalSpan.setAttribute("neurolink.request_id", context.requestId);
             internalSpan.setAttribute("neurolink.has_conversation_memory", !!this.conversationMemory);
             internalSpan.setAttribute("neurolink.provider", options.provider || "auto");
@@ -5514,6 +5524,7 @@ Current user's request: ${currentInput}`;
             throw error;
         }
         finally {
+            cleanup();
             internalSpan.end();
         }
     }
@@ -5544,6 +5555,7 @@ Current user's request: ${currentInput}`;
                     internalSpan,
                     requestId: context.requestId,
                     startTime: context.generateInternalStartTime,
+                    events: context.eventSequence,
                 });
             }
             if (options.abortSignal?.aborted) {
@@ -5559,6 +5571,7 @@ Current user's request: ${currentInput}`;
                 internalSpan,
                 requestId: context.requestId,
                 startTime: context.generateInternalStartTime,
+                events: context.eventSequence,
             });
         }
         catch (error) {
@@ -5586,7 +5599,11 @@ Current user's request: ${currentInput}`;
             : undefined;
     }
     async finalizeGenerateTextInternalResult(params) {
-        const { path, result, options, internalSpan, requestId, startTime } = params;
+        const { path, result, options, internalSpan, requestId, startTime, events, } = params;
+        const historyEvents = events?.filter((event) => event.type !== "response:chunk");
+        if (historyEvents?.length) {
+            result.events = historyEvents;
+        }
         logger.info(`[NeuroLink.generateTextInternal] generate() - COMPLETE SUCCESS${path === "mcp" ? " (MCP path)" : ""}`, {
             provider: result.provider,
             model: result.model,
@@ -7347,7 +7364,36 @@ Current user's request: ${currentInput}`;
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
     async stream(options) {
-        return logger.runInInstanceScope(this.logInstanceId, () => this.streamInInstanceScope(options));
+        const eventScope = Symbol("stream-conversation");
+        return this.conversationEventContext.run(eventScope, () => logger.runInInstanceScope(this.logInstanceId, async () => {
+            const result = await this.streamInInstanceScope(options);
+            return preserveLiveStreamAccessors(result, {
+                ...result,
+                stream: this.bindConversationEventStream(result.stream, eventScope),
+            });
+        }));
+    }
+    /** Re-enter request ownership when the caller drives a deferred async iterator. */
+    bindConversationEventStream(stream, eventScope) {
+        const scope = this.conversationEventContext;
+        return (async function* () {
+            const iterator = stream[Symbol.asyncIterator]();
+            try {
+                while (true) {
+                    const next = await scope.run(eventScope, () => iterator.next());
+                    if (next.done) {
+                        return;
+                    }
+                    yield next.value;
+                }
+            }
+            finally {
+                const close = iterator.return?.bind(iterator);
+                if (close) {
+                    await scope.run(eventScope, () => close());
+                }
+            }
+        })();
     }
     /**
      * Body of {@link stream}, always entered through the instance log scope.
@@ -7909,7 +7955,11 @@ Current user's request: ${currentInput}`;
             // (Finding 1 fix). It is cleared by setToolRoutingServers() when the
             // catalog changes so stale vectors are never used after an update.
             let routingEmbedFn;
-            const embeddingCfg = routingConfig.embedding;
+            // A host-owned routing callback owns every inference account. The
+            // instance's embedding fast-path would otherwise borrow turn credentials.
+            const embeddingCfg = routingConfig.generateFn
+                ? undefined
+                : routingConfig.embedding;
             if (embeddingCfg?.enabled === true) {
                 try {
                     // Resolve the embedding provider: use the explicitly configured one
@@ -7959,7 +8009,7 @@ Current user's request: ${currentInput}`;
                 timeoutMs: routingConfig.timeoutMs ?? DEFAULT_TOOL_ROUTING_TIMEOUT_MS,
                 // Forward the abort signal so a cancelled turn aborts the router
                 // call promptly instead of waiting out the routing timeout.
-                generateFn: (generateOptions) => this.preservingTurnState(() => this.generate({
+                generateFn: (generateOptions) => this.preservingTurnState(() => (routingConfig.generateFn ?? ((input) => this.generate(input)))({
                     ...generateOptions,
                     abortSignal: options.abortSignal,
                 })),
@@ -7967,7 +8017,11 @@ Current user's request: ${currentInput}`;
                 // configured. siteDecide returns null without one, so the resolver
                 // falls straight through to the generative router as before. The
                 // outer request's credentials, abort signal and ids ride along.
-                decideFn: (decisionOptions) => this.siteDecide(decisionOptions, this.decisionSiteContext(options, sessionId || undefined)),
+                // A host-owned routing callback owns the inference account too.
+                // Bypass the instance's decision fast-path in that explicit mode.
+                decideFn: routingConfig.generateFn
+                    ? undefined
+                    : (decisionOptions) => this.siteDecide(decisionOptions, this.decisionSiteContext(options, sessionId || undefined)),
                 decisionMinDropConfidence: routingConfig.minDropConfidence,
                 emitDecision: captureDecision,
                 // L2 / ITEM D — only populated when embedding is configured.
@@ -8948,7 +9002,30 @@ Current user's request: ${currentInput}`;
     setupStreamEventListeners() {
         const eventSequence = [];
         let eventSeqCounter = 0;
-        const captureEvent = (type, data) => {
+        const eventScope = this.conversationEventContext.getStore();
+        const ownedConfirmations = new Set();
+        const confirmationId = (event) => {
+            if (!event ||
+                typeof event !== "object" ||
+                !("payload" in event) ||
+                !event.payload ||
+                typeof event.payload !== "object" ||
+                !("confirmationId" in event.payload) ||
+                typeof event.payload.confirmationId !== "string") {
+                return undefined;
+            }
+            return event.payload.confirmationId;
+        };
+        const captureEvent = (type, data, ownedConfirmation) => {
+            // Never infer ownership from whichever listeners happen to be active.
+            // This also fails closed where async context propagation is unavailable.
+            const belongsToTurn = eventScope !== undefined &&
+                this.conversationEventContext.getStore() === eventScope;
+            const belongsToConfirmation = ownedConfirmation !== undefined &&
+                ownedConfirmations.has(ownedConfirmation);
+            if (!belongsToTurn && !belongsToConfirmation) {
+                return;
+            }
             eventSequence.push({
                 type,
                 seq: eventSeqCounter++,
@@ -8990,19 +9067,46 @@ Current user's request: ${currentInput}`;
                 });
             }
         };
+        const onHostConversationEvent = (...args) => {
+            const event = args[0];
+            if (event &&
+                typeof event === "object" &&
+                "type" in event &&
+                typeof event.type === "string" &&
+                "data" in event &&
+                event.data &&
+                typeof event.data === "object" &&
+                !Array.isArray(event.data)) {
+                captureEvent(event.type, { data: event.data });
+            }
+        };
         const onUIComponent = (...args) => {
             captureEvent("ui-component", args[0]);
         };
         const onHITLRequest = (...args) => {
-            captureEvent("hitl:confirmation-request", args[0]);
+            if (eventScope !== undefined &&
+                this.conversationEventContext.getStore() === eventScope) {
+                const id = confirmationId(args[0]);
+                if (id !== undefined) {
+                    ownedConfirmations.add(id);
+                }
+                captureEvent("hitl:confirmation-request", args[0]);
+            }
         };
         const onHITLResponse = (...args) => {
-            captureEvent("hitl:confirmation-response", args[0]);
+            const id = confirmationId(args[0]);
+            // A host answers from its own HTTP/async context. The issued confirmation
+            // id carries ownership without admitting arbitrary global emitter data.
+            if (id !== undefined && ownedConfirmations.has(id)) {
+                captureEvent("hitl:confirmation-response", args[0], id);
+                ownedConfirmations.delete(id);
+            }
         };
         this.emitter.on("response:chunk", onResponseChunk);
         this.emitter.on("tool:start", onToolStart);
         this.emitter.on("tool:end", onToolEnd);
         this.emitter.on("ui-component", onUIComponent);
+        this.emitter.on("host:conversation-event", onHostConversationEvent);
         this.emitter.on("hitl:confirmation-request", onHITLRequest);
         this.emitter.on("hitl:confirmation-response", onHITLResponse);
         const cleanup = () => {
@@ -9010,6 +9114,7 @@ Current user's request: ${currentInput}`;
             this.emitter.off("tool:start", onToolStart);
             this.emitter.off("tool:end", onToolEnd);
             this.emitter.off("ui-component", onUIComponent);
+            this.emitter.off("host:conversation-event", onHostConversationEvent);
             this.emitter.off("hitl:confirmation-request", onHITLRequest);
             this.emitter.off("hitl:confirmation-response", onHITLResponse);
         };

package/dist/providers/anthropic/client.js

@@ -2008,6 +2008,7 @@ export class AnthropicProvider extends BaseProvider {
                             steps: stepRecords,
                             maxSteps,
                             model: modelId,
+                            declaredTools: toolsRecord,
                             ...(abortSignal ? { abortSignal } : {}),
                         })))
                     : undefined;

package/dist/providers/openaiChatCompletionsBase.js

@@ -1741,6 +1741,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                             steps,
                             maxSteps,
                             model: modelId,
+                            declaredTools: toolsRecord,
                             ...(abortSignal ? { abortSignal } : {}),
                         }), wireNameMaps?.toWire)
                         : undefined,

package/dist/types/agentNetwork.d.ts

@@ -7,7 +7,7 @@
 import type { z } from "zod";
 import type { AIProviderName } from "../constants/enums.js";
 import type { TokenUsage } from "./analytics.js";
-import type { GenerateStopReason, ToolExecutionRecord } from "./generate.js";
+import type { GenerateStopReason, ToolExecutionRecord, ToolExecutionCaptureOptions } from "./generate.js";
 /**
  * Agent definition for creating agents in the network
  */
@@ -86,6 +86,20 @@ export type AgentExecutionOptions = {
     enableAnalytics?: boolean;
     /** Cumulative budget for the NeuroLink instance, not a per-run cap. */
     maxBudgetUsd?: number;
+    /** Per-turn tool opt-out; cannot expand the agent tool scope. */
+    disableTools?: boolean;
+    /** Provider region override for this turn. */
+    region?: string;
+    /** Output bound for this turn. */
+    maxTokens?: number;
+    /** Opt out of session history and user-memory reads/writes for this turn, retaining stored state. */
+    useMemory?: boolean;
+    /** Conversation memory identity; never included in the model prompt. */
+    sessionId?: string;
+    /** Refuse SDK-internal provider/model fallback for this execution. */
+    disableInternalFallback?: boolean;
+    /** Bounds and callback for the underlying SDK's tool execution capture. */
+    toolExecutionCapture?: ToolExecutionCaptureOptions;
     /** Additional context for the agent */
     context?: Record<string, unknown>;
     /** Override max steps for this execution */
@@ -493,6 +507,12 @@ export type AgentStreamChunk = {
     usage?: TokenUsage;
     /** Duration in ms (for complete chunks) */
     duration?: number;
+    /** Complete-turn status; errors remain failures even after partial text. */
+    status?: AgentResult["status"];
+    /** Final, bounded per-call records in the same shape as AgentResult. */
+    toolExecutions?: ToolExecutionRecord[];
+    /** Terminal reason from the underlying stream. */
+    stopReason?: GenerateStopReason;
     /** Error message (for error chunks) */
     error?: string;
     /** Tool name (for tool chunks) */

package/dist/types/common.d.ts

@@ -93,6 +93,11 @@ export type InternalStreamEvent = {
  * Flexible type to support both typed and legacy event patterns
  */
 export type NeuroLinkEvents = {
+    /** Application-owned events captured in ordered conversation history. */
+    "host:conversation-event": {
+        type: string;
+        data: Record<string, unknown>;
+    };
     "tool:start": unknown;
     "tool:end": unknown;
     "stream:start": unknown;

package/dist/types/generate.d.ts

@@ -7,7 +7,7 @@ import type { ClaudeLimitSnapshot } from "./subscription.js";
 import type { JsonValue } from "./common.js";
 import type { TerminalAgentModeOption, TerminalAgentModeVersion } from "./agentMode.js";
 import type { Content, ImageWithAltText } from "./content.js";
-import type { ChatMessage, ConversationMemoryConfig, ToolReplayMode } from "./conversation.js";
+import type { ChatMessage, ConversationMemoryConfig, StreamEventSequence, ToolReplayMode } from "./conversation.js";
 import type { MemoryCallOptions } from "./memory.js";
 import type { EvaluationData } from "./evaluation.js";
 import type { MiddlewareFactoryOptions, OnFinishCallback, OnErrorCallback } from "./middleware.js";
@@ -584,6 +584,10 @@ export type GenerateOptions = {
      * compel a tool call on every step, and the loop would only end when
      * `maxSteps` ran out. `"auto"` and `"none"` are applied unchanged on every
      * step. Vertex, Google AI Studio and Bedrock do not honour `toolChoice`.
+     *
+     * A named tool that the request does not declare is not sent, because the
+     * provider would reject the request: a warning is logged and the step uses
+     * `"auto"`.
      */
     toolChoice?: ToolChoice<Record<string, Tool>>;
     /**
@@ -606,7 +610,9 @@ export type GenerateOptions = {
      * Optional callback that runs before each step in a multi-step generation.
      *
      * Honoured field of the result: `toolChoice`, applied to that step only
-     * and taking precedence over `toolChoice` / `toolChoiceSteps`.
+     * and taking precedence over `toolChoice` / `toolChoiceSteps`. A named tool
+     * the request does not declare is ignored with a warning, as if the hook had
+     * returned no `toolChoice`.
      *
      * Not honoured — accepted for source compatibility with the former Vercel
      * AI SDK `experimental_prepareStep` shape, but ignored by every native
@@ -1663,6 +1669,8 @@ export type TextGenerationOptions = {
  * Text generation result (consolidated from core types)
  */
 export type TextGenerationResult = {
+    /** Ordered tool and host events persisted with the conversation turn. */
+    events?: StreamEventSequence[];
     content: string;
     /** Parsed structured object when a `schema` was requested (see GenerateResult.structuredData). */
     structuredData?: unknown;
@@ -1797,6 +1805,17 @@ export type StepToolChoiceInput = {
     model: string;
     /** The turn's abort signal; a pending `prepareStep` is released when it fires. */
     abortSignal?: AbortSignal;
+    /**
+     * The tools this request declares, keyed by SDK-side tool name. When given,
+     * a forced single-tool choice naming a tool outside it is not sent: a
+     * provider answers a request that forces a function its own tools list
+     * lacks with a 400. A loop that re-declares hydrated tools in the same
+     * step (the streaming loops) passes the live record, because discovery
+     * hydrates tools into it between steps; a loop that sends a fixed tools
+     * array (the shared generate loop) passes the names of that array.
+     * Absent means the choice is not checked.
+     */
+    declaredTools?: Readonly<Record<string, unknown>>;
 };
 /**
  * Inputs to the shared native generate loop (`core/nativeGenerateLoop.ts`).

package/dist/types/toolRouting.d.ts

@@ -106,6 +106,12 @@ export type ToolRoutingEmbeddingConfig = {
 };
 /** Constructor-level configuration for pre-call tool routing. */
 export type ToolRoutingConfig = {
+    /**
+     * Host-owned generative routing, independent of main-turn credentials.
+     * When provided, instance decision and embedding fast-paths are bypassed;
+     * routing selection is performed by this callback.
+     */
+    generateFn?: (options: GenerateOptions) => Promise<GenerateResult>;
     /** Master switch. Routing runs only when true AND the server catalog is non-empty. */
     enabled: boolean;
     /**

package/dist/utils/conversationMemory.js

@@ -384,7 +384,7 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
                 providerDetails,
                 enableSummarization: originalOptions.enableSummarization,
                 requestId,
-                events: toolActivityEvents,
+                events: result.events?.length ? result.events : toolActivityEvents,
                 ...(skillMessages && skillMessages.length > 0
                     ? { skillMessages }
                     : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.49.18",
+  "version": "12.49.20",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {
@@ -75,6 +75,8 @@
     "test": "pnpm exec tsx test/continuous-test-suite.ts",
     "test:agent-delegation": "pnpm exec tsx test/continuous-test-suite-agent-delegation.ts",
     "test:agent-tasks": "pnpm exec tsx test/continuous-test-suite-agent-tasks.ts",
+    "test:agent:session-stream": "pnpm exec tsx test/continuous-test-suite-agent-session-stream.ts",
+    "test:agent:platform-router": "pnpm exec tsx test/continuous-test-suite-agent-platform-router.ts",
     "test:artifact-banking": "pnpm exec tsx test/continuous-test-suite-artifact-banking.ts",
     "test:background-commands": "pnpm exec tsx test/continuous-test-suite-background-commands.ts",
     "test:client": "pnpm exec tsx test/continuous-test-suite-client.ts",
@@ -110,6 +112,7 @@
     "test:agent:cost": "pnpm exec tsx test/continuous-test-suite-agent-cost.ts",
     "test:adjust-body-after-400": "pnpm exec tsx test/continuous-test-suite-adjust-body-after-400.ts",
     "test:zod3-schema-native-path": "pnpm exec tsx test/continuous-test-suite-zod3-schema-native-path.ts",
+    "test:forced-tool-declared": "pnpm exec tsx test/continuous-test-suite-forced-tool-declared.ts",
     "test:error-classification-e2e": "pnpm exec tsx test/continuous-test-suite-error-classification-e2e.ts",
     "test:error-classifier-contract": "pnpm exec tsx test/continuous-test-suite-error-classifier-contract.ts",
     "test:bedrock-inference-profile": "pnpm exec tsx test/continuous-test-suite-bedrock-inference-profile.ts",