@juspay/neurolink 12.49.18 → 12.49.19

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/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";
@@ -1663,6 +1663,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;

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.19",
   "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",