@juspay/neurolink 12.41.3 → 12.41.5

package/dist/core/baseProvider.js

@@ -24,7 +24,7 @@ import { sanitizeErrorCause } from "../utils/logSanitize.js";
 import { createAnalytics as buildAnalytics } from "./analytics.js";
 import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
 import { duckTypedStatusCode, extractRetryAfterMsFromError, } from "../utils/providerRetry.js";
-import { hasLifecycleErrorFired, markLifecycleErrorFired, } from "../utils/lifecycleCallbacks.js";
+import { getLifecycleMiddlewareConfig, hasLifecycleErrorFired, markLifecycleErrorFired, } from "../utils/lifecycleCallbacks.js";
 import { resolveLifecycleTimeoutMs } from "../utils/lifecycleTimeout.js";
 import { logger } from "../utils/logger.js";
 import { interleaveTTSStream } from "../utils/ttsStream.js";
@@ -51,18 +51,6 @@ import { generateOnceNative } from "../utils/nativeSingleShot.js";
 import { validateExecutionControl } from "../utils/parameterValidation.js";
 import { extractTokenUsage } from "../utils/tokenUtils.js";
 import { preserveLiveStreamAccessors } from "../utils/streamResultAccessors.js";
-/**
- * Read the consumer-facing lifecycle callbacks buried inside a request's
- * middleware blob. The parameter is `unknown` on purpose: request options
- * arrive as several structurally-unrelated shapes (StreamOptions,
- * TextGenerationOptions), and the lifecycle branch is an optional add-on
- * none of them declare — a single structural view keeps the read cast-free
- * at every call site.
- */
-function getLifecycleMiddlewareConfig(options) {
-    return options?.middleware
-        ?.middlewareConfig?.lifecycle?.config;
-}
 /**
  * Abstract base class for all AI providers
  * Tools are integrated as first-class citizens - always available by default
@@ -819,9 +807,32 @@ export class BaseProvider {
                     yield chunk;
                 }
                 if (onFinish) {
+                    // Read `result.usage` / `result.finishReason` here, after the
+                    // drain loop above has fully exhausted `upstreamIterable` — the
+                    // same point native background-loop providers (Vertex's Gemini3
+                    // and Claude paths) resolve these fields by, whether they are
+                    // plain values set before `result` was returned or live getters
+                    // preserved through `withStreamModelFallback`
+                    // (`preserveLiveStreamAccessors`). Both fields are generic
+                    // `StreamResult` members for every provider, not Vertex-specific,
+                    // so this enrichment is additive for all of them: only present
+                    // when `result` actually carries a value, never a synthesized
+                    // default (a provider that never populated these fields keeps
+                    // getting the exact same bare `{text, duration}` payload as
+                    // before).
+                    const { usage, finishReason } = result;
                     await safeFire(() => onFinish({
                         text: accumulated,
                         duration: Date.now() - startTime,
+                        ...(usage
+                            ? {
+                                usage: {
+                                    promptTokens: usage.input ?? 0,
+                                    completionTokens: usage.output ?? 0,
+                                },
+                            }
+                            : {}),
+                        ...(finishReason ? { finishReason } : {}),
                     }), "onFinish");
                 }
             }

package/dist/middleware/builtin/lifecycle.js

@@ -1,6 +1,6 @@
 import { logger } from "../../utils/logger.js";
 import { isRecoverableError } from "../../utils/errorHandling.js";
-import { fireOnErrorOnce } from "../../utils/lifecycleCallbacks.js";
+import { fireOnErrorOnce, isLifecycleStreamCallbacksOwnedByBaseProvider, } from "../../utils/lifecycleCallbacks.js";
 /**
  * Normalize a thrown value to an `Error` while preserving structured
  * fields (`code`, `status`, `statusCode`, `retryAfter`, `details`,
@@ -88,19 +88,42 @@ export function createLifecycleMiddleware(config = {}) {
                 if (!config.onChunk && !config.onFinish && !config.onError) {
                     return result;
                 }
+                // BaseProvider.wrapStreamWithLifecycleCallbacks already fires
+                // onChunk/onFinish for this exact config object, from NeuroLink's
+                // own normalized stream, for every NeuroLink-internal stream() call
+                // regardless of provider/transport. When that marker is present,
+                // firing onChunk/onFinish here too would deliver each one twice —
+                // once from these raw, provider-shaped V3 chunks, once from
+                // BaseProvider's normalized ones. onError is NOT covered by this
+                // flag: it keeps its own, independent dedup via `fireOnErrorOnce`'s
+                // shared fired-marker below, unchanged.
+                const streamCallbacksOwnedByBaseProvider = isLifecycleStreamCallbacksOwnedByBaseProvider(config);
                 let sequenceNumber = 0;
                 let accumulatedText = "";
                 const transformStream = new TransformStream({
                     transform(chunk, controller) {
                         try {
-                            if (chunk.type === "text-delta") {
-                                accumulatedText += chunk.textDelta;
+                            // V3 stream parts carry the delta on `delta` (see
+                            // LanguageModelV3StreamPart in types/aiCompat.ts); `textDelta`
+                            // is a V2-era AI-SDK field that V3 providers (e.g. Bedrock's
+                            // bridge, this package's own openaiChatCompletionsBase) never
+                            // set. Reading `chunk.textDelta` alone silently produced
+                            // `undefined`, which string-concatenated into a literal
+                            // "undefined" per chunk. Falling back to `textDelta` keeps any
+                            // caller still emitting the older shape working unchanged.
+                            const textDelta = chunk.type === "text-delta"
+                                ? (chunk.delta ?? chunk.textDelta)
+                                : undefined;
+                            if (chunk.type === "text-delta" && textDelta !== undefined) {
+                                accumulatedText += textDelta;
                             }
-                            if (config.onChunk && chunk.type) {
+                            if (config.onChunk &&
+                                chunk.type &&
+                                !streamCallbacksOwnedByBaseProvider) {
                                 try {
                                     const callbackResult = config.onChunk({
                                         type: chunk.type,
-                                        textDelta: chunk.type === "text-delta" ? chunk.textDelta : undefined,
+                                        textDelta,
                                         sequenceNumber: sequenceNumber++,
                                     });
                                     Promise.resolve(callbackResult).catch((e) => {
@@ -124,7 +147,7 @@ export function createLifecycleMiddleware(config = {}) {
                         }
                     },
                     flush() {
-                        if (config.onFinish) {
+                        if (config.onFinish && !streamCallbacksOwnedByBaseProvider) {
                             try {
                                 const callbackResult = config.onFinish({
                                     text: accumulatedText,

package/dist/neurolink.js

@@ -79,7 +79,7 @@ import { tracers } from "./telemetry/tracers.js";
 import { getConversationMessages, storeConversationTurn, } from "./utils/conversationMemory.js";
 // Enhanced error handling imports
 import { CircuitBreaker, ERROR_CODES, ErrorFactory, isAbortError, isRetriableError, logStructuredError, NeuroLinkError, withRetry, withTimeout, } from "./utils/errorHandling.js";
-import { hasLifecycleErrorFired, markLifecycleErrorFired, } from "./utils/lifecycleCallbacks.js";
+import { hasLifecycleErrorFired, markLifecycleErrorFired, markLifecycleStreamCallbacksOwnedByBaseProvider, } from "./utils/lifecycleCallbacks.js";
 import { interleaveTTSStream } from "./utils/ttsStream.js";
 import { resolveLifecycleTimeoutMs } from "./utils/lifecycleTimeout.js";
 import { cloneOptionsForCallIsolation } from "./utils/cloneOptions.js";
@@ -782,6 +782,20 @@ export class NeuroLink {
         if (!options.onFinish && !options.onError && !options.onChunk) {
             return;
         }
+        const config = {
+            ...options.middleware?.middlewareConfig?.lifecycle?.config,
+            ...(options.onFinish !== undefined ? { onFinish: options.onFinish } : {}),
+            ...(options.onError !== undefined ? { onError: options.onError } : {}),
+            ...(options.onChunk !== undefined ? { onChunk: options.onChunk } : {}),
+        };
+        // BaseProvider.wrapStreamWithLifecycleCallbacks unconditionally wraps
+        // every provider's stream() result and fires onChunk/onFinish from
+        // there, reliably, for this exact config object. Stamp it so the
+        // model-level lifecycle middleware (builtin/lifecycle.ts) skips its own
+        // onChunk/onFinish firing for it instead of delivering each one twice.
+        // See markLifecycleStreamCallbacksOwnedByBaseProvider's doc comment for
+        // why generate()'s config below is never stamped this way.
+        markLifecycleStreamCallbacksOwnedByBaseProvider(config);
         options.middleware = {
             ...options.middleware,
             middlewareConfig: {
@@ -789,18 +803,7 @@ export class NeuroLink {
                 lifecycle: {
                     ...options.middleware?.middlewareConfig?.lifecycle,
                     enabled: true,
-                    config: {
-                        ...options.middleware?.middlewareConfig?.lifecycle?.config,
-                        ...(options.onFinish !== undefined
-                            ? { onFinish: options.onFinish }
-                            : {}),
-                        ...(options.onError !== undefined
-                            ? { onError: options.onError }
-                            : {}),
-                        ...(options.onChunk !== undefined
-                            ? { onChunk: options.onChunk }
-                            : {}),
-                    },
+                    config,
                 },
             },
         };

package/dist/providers/amazonBedrock/client.d.ts

@@ -68,6 +68,33 @@ export declare class AmazonBedrockProvider extends BaseProvider {
     private convertToBedrockMessages;
     getBedrockClient(): BedrockRuntimeClient;
     protected executeStream(options: StreamOptions): Promise<StreamResult>;
+    /**
+     * A multimodal turn skips model middleware (see modelBridge.ts's header).
+     * WARN when middleware was configured, per request or on the provider,
+     * since it silently did not run; multimodal turns alone are unremarkable,
+     * so stay at debug otherwise.
+     */
+    private logMultimodalMiddlewareSkip;
+    /**
+     * `inferenceConfig` carries `maxTokens` and `temperature` only, so any other
+     * sampling option a middleware sets would be dropped without a trace.
+     * `tools` is reported where it is compared, at each call site.
+     */
+    private warnOnUnsentMiddlewareOptions;
+    /**
+     * Runs the turn behind `streamingConversationLoop`: the model-middleware
+     * path for a text-only starting turn, or the direct fallback for a
+     * multimodal one. Extracted only to keep `streamingConversationLoop`
+     * readable — the branching logic itself is unchanged from what it
+     * replaced.
+     */
+    private buildBedrockStreamTurn;
+    /**
+     * Turns a settled loop outcome's usage into the shape both the analytics
+     * resolution and the stream's own `finally` block report. Shared so the
+     * two call sites in `streamingConversationLoop` can't drift.
+     */
+    private summarizeBedrockStreamUsage;
     private streamingConversationLoop;
     /**
      * Health check for Amazon Bedrock service