@juspay/neurolink 12.35.2 → 12.35.4

package/dist/neurolink.js

@@ -8146,8 +8146,30 @@ Current user's request: ${currentInput}`;
             const streamResult = await this.processStreamResult(processedStream, enhancedOptions, factoryResult);
             streamResult.finishReason =
                 streamState.finishReason || streamResult.finishReason;
-            streamResult.toolCalls = streamState.toolCalls;
-            streamResult.toolResults = streamState.toolResults;
+            // Unresolved #1819 review comment: a top-level cross-provider fallback
+            // (handleStreamFallback, inside `processedStream` above) only
+            // reassigns `streamState.toolCalls`/`toolResults` once the caller
+            // starts draining the stream — strictly AFTER this point, since
+            // `processedStream` is a lazy async generator and the
+            // `processStreamResult` call above resolves without pulling a single
+            // chunk. A plain value copy here (`streamResult.toolCalls =
+            // streamState.toolCalls`) would freeze whatever streamState held at
+            // THIS instant — the primary attempt's (usually empty) arrays —
+            // because a property assignment is not a live binding. Define live
+            // getters instead so every later read reflects streamState's current
+            // value, mirroring the pattern #1819 already used to keep
+            // finishReason/usage/model live via getters over streamState/
+            // mcpStreamOutcome.
+            Object.defineProperty(streamResult, "toolCalls", {
+                enumerable: true,
+                configurable: true,
+                get: () => streamState.toolCalls,
+            });
+            Object.defineProperty(streamResult, "toolResults", {
+                enumerable: true,
+                configurable: true,
+                get: () => streamState.toolResults,
+            });
             if (!streamResult.usage) {
                 streamResult.usage = mcpStreamOutcome.usage;
             }
@@ -9103,13 +9125,27 @@ Current user's request: ${currentInput}`;
             model: source?.model ?? config.options.model,
             usage: streamResult.usage,
             finishReason: streamResult.finishReason,
-            toolCalls: streamResult.toolCalls,
-            toolResults: streamResult.toolResults,
             analytics: streamResult.analytics,
             evaluation: streamResult.evaluation,
             events: config.events && config.events.length > 0 ? config.events : undefined,
             metadata: source ? undefined : Object.assign({}, responseMetadata),
         };
+        // Unresolved #1819 review comment: toolCalls/toolResults must stay bound
+        // to `streamResult`'s own live getters (defined in stream(), right after
+        // processStreamResult) rather than the plain values a
+        // `toolCalls: streamResult.toolCalls` literal above would have captured
+        // — that reads the getter once and freezes whatever streamState held
+        // before a top-level cross-provider fallback (handleStreamFallback) had
+        // a chance to reassign it. Copying the property DESCRIPTOR, not its
+        // current value, keeps every later read on `response` live too.
+        const toolCallsDescriptor = Object.getOwnPropertyDescriptor(streamResult, "toolCalls");
+        if (toolCallsDescriptor) {
+            Object.defineProperty(response, "toolCalls", toolCallsDescriptor);
+        }
+        const toolResultsDescriptor = Object.getOwnPropertyDescriptor(streamResult, "toolResults");
+        if (toolResultsDescriptor) {
+            Object.defineProperty(response, "toolResults", toolResultsDescriptor);
+        }
         if (!source) {
             return response;
         }
@@ -9117,14 +9153,26 @@ Current user's request: ${currentInput}`;
         // finishReason, stopReason for aborts and time limits), so those fields
         // stay plain values here. Copying the provider's getter for them would
         // report the raw vendor reason, e.g. Anthropic's end_turn, instead.
-        const gradedTerminalFields = new Set([
+        //
+        // toolCalls/toolResults are excluded for a different reason: `source`
+        // (the PRIMARY provider's own result) may itself define them as live
+        // getters over BaseProvider.withStreamModelFallback's `activeResult`
+        // (#1819) — which only ever tracks a SAME-PROVIDER model retry. Copying
+        // that descriptor here would silently re-point `response.toolCalls`/
+        // `toolResults` back at the primary attempt, undoing the descriptor
+        // copy above that binds them to `streamResult`'s `streamState`-backed
+        // getters — the ones that actually track a top-level cross-provider
+        // fallback.
+        const liveAccessorExclusions = new Set([
             "finishReason",
             "stopReason",
             "rawFinishReason",
+            "toolCalls",
+            "toolResults",
         ]);
         for (const key of Object.getOwnPropertyNames(source)) {
             const descriptor = Object.getOwnPropertyDescriptor(source, key);
-            if (!gradedTerminalFields.has(key) &&
+            if (!liveAccessorExclusions.has(key) &&
                 descriptor &&
                 typeof descriptor.get === "function") {
                 Object.defineProperty(response, key, descriptor);
@@ -9133,7 +9181,19 @@ Current user's request: ${currentInput}`;
         Object.defineProperty(response, "metadata", {
             enumerable: true,
             configurable: true,
-            get: () => Object.assign(source.metadata ?? {}, responseMetadata),
+            get: () => {
+                // A caller mutation (`result.metadata.x = 1`) must persist across
+                // reads. The previous `Object.assign(source.metadata ?? {},
+                // responseMetadata)` allocated a brand-new object every time
+                // `source.metadata` was undefined, so the mutation landed on a
+                // value discarded immediately after. Installing a persistent object
+                // into `source.metadata` the first time makes every later read
+                // return the SAME object, so mutations on it stick.
+                if (source.metadata === undefined) {
+                    source.metadata = {};
+                }
+                return Object.assign(source.metadata, responseMetadata);
+            },
             set: (value) => {
                 source.metadata = value;
             },

package/dist/server/abstract/baseServerAdapter.d.ts

@@ -28,8 +28,12 @@ export declare abstract class BaseServerAdapter extends EventEmitter {
     constructor(neurolink: NeuroLink, config?: ServerAdapterConfig);
     /**
      * Initialize the underlying server framework
+     * May be async: adapters that dynamically import their framework package
+     * (e.g. Hono) return a Promise; adapters with a synchronous no-op stub that
+     * defer real setup to their own overridden `initialize()` (Express/Fastify/
+     * Koa) still return void.
      */
-    protected abstract initializeFramework(): void;
+    protected abstract initializeFramework(): void | Promise<void>;
     /**
      * Register a route with the framework
      */

package/dist/server/abstract/baseServerAdapter.js

@@ -145,7 +145,7 @@ export class BaseServerAdapter extends EventEmitter {
         const startTime = Date.now();
         try {
             // Initialize framework-specific setup
-            this.initializeFramework();
+            await this.initializeFramework();
             // Register built-in middleware
             this.registerBuiltInMiddleware();
             // Register built-in routes

package/dist/server/adapters/honoAdapter.d.ts

@@ -16,6 +16,8 @@ export declare class HonoServerAdapter extends BaseServerAdapter {
     private rateLimitStore;
     private rateLimitCleanupInterval?;
     private requestContextStore;
+    private HTTPExceptionCtor;
+    private streamSSEFn;
     constructor(neurolink: NeuroLink, config?: ServerAdapterConfig);
     /**
      * Create rate limiter middleware for Hono
@@ -27,8 +29,10 @@ export declare class HonoServerAdapter extends BaseServerAdapter {
     private cleanupRateLimitStore;
     /**
      * Initialize Hono framework
+     * Dynamically imports Hono and its middleware so requiring only another
+     * adapter (Express/Fastify/Koa) never pulls Hono's import graph in.
      */
-    protected initializeFramework(): void;
+    protected initializeFramework(): Promise<void>;
     /**
      * Register route with Hono
      */

package/dist/server/adapters/honoAdapter.js

@@ -3,13 +3,6 @@
  * Primary server adapter implementation using Hono framework
  * Hono is chosen for its performance, TypeScript-first design, and edge compatibility
  */
-import { Hono } from "hono";
-import { cors } from "hono/cors";
-import { HTTPException } from "hono/http-exception";
-import { logger as honoLogger } from "hono/logger";
-import { secureHeaders } from "hono/secure-headers";
-import { streamSSE } from "hono/streaming";
-import { timeout } from "hono/timeout";
 import { logger } from "../../utils/logger.js";
 import { AlreadyRunningError, ServerStopError, wrapError } from "../errors.js";
 import { BaseServerAdapter } from "../abstract/baseServerAdapter.js";
@@ -25,6 +18,11 @@ export class HonoServerAdapter extends BaseServerAdapter {
     rateLimitCleanupInterval;
     // Store context by request ID for sharing between middleware and route handlers
     requestContextStore = new Map();
+    // Populated by initializeFramework's dynamic imports; used by methods that
+    // run after initialization (route registration, streaming) and so cannot
+    // rely on initializeFramework's own local closure variables.
+    HTTPExceptionCtor;
+    streamSSEFn;
     constructor(neurolink, config = {}) {
         super(neurolink, config);
     }
@@ -113,8 +111,21 @@ export class HonoServerAdapter extends BaseServerAdapter {
     }
     /**
      * Initialize Hono framework
+     * Dynamically imports Hono and its middleware so requiring only another
+     * adapter (Express/Fastify/Koa) never pulls Hono's import graph in.
      */
-    initializeFramework() {
+    async initializeFramework() {
+        const [{ Hono }, { cors }, { HTTPException }, { logger: honoLogger }, { secureHeaders }, { streamSSE }, { timeout },] = await Promise.all([
+            this.importFrameworkDependency("hono", "hono"),
+            this.importFrameworkDependency("hono/cors", "hono"),
+            this.importFrameworkDependency("hono/http-exception", "hono"),
+            this.importFrameworkDependency("hono/logger", "hono"),
+            this.importFrameworkDependency("hono/secure-headers", "hono"),
+            this.importFrameworkDependency("hono/streaming", "hono"),
+            this.importFrameworkDependency("hono/timeout", "hono"),
+        ]);
+        this.HTTPExceptionCtor = HTTPException;
+        this.streamSSEFn = streamSSE;
         this.app = new Hono();
         // Add secure headers
         this.app.use("*", secureHeaders());
@@ -284,7 +295,7 @@ export class HonoServerAdapter extends BaseServerAdapter {
                     route: route.path,
                     error: errorMessage,
                 });
-                throw new HTTPException(500, { message: errorMessage });
+                throw new this.HTTPExceptionCtor(500, { message: errorMessage });
             }
             finally {
                 // Untrack connection when request completes
@@ -304,7 +315,7 @@ export class HonoServerAdapter extends BaseServerAdapter {
                 c.header(key, value);
             }
         }
-        return streamSSE(c, async (stream) => {
+        return this.streamSSEFn(c, async (stream) => {
             try {
                 // Get streaming result from handler
                 const result = await route.handler(ctx);