@juspay/neurolink 12.41.3 → 12.41.5

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

@@ -0,0 +1,100 @@
+/**
+ * Bridges Bedrock's native `BedrockMessage[]` conversation shape and
+ * `AgenticLoopChunk` stream to the AI SDK V3 model-middleware protocol
+ * (`LanguageModelV3`), so `BaseProvider.applyMiddlewareToModel()` can wrap a
+ * turn built entirely out of `runAgenticLoop` — the same engine Bedrock's
+ * `generate()` and `executeStream()` already run on.
+ *
+ * Scope: only the conversation `generate()`/`executeStream()` hand to the
+ * loop as its STARTING point ever crosses this boundary. Both reset
+ * `conversationHistory` to a single fresh message before calling the loop
+ * (see `client.ts`), so that starting point is always `system + one user
+ * message` — never prior assistant/tool-result turns, which are constructed
+ * entirely inside the loop's own steps and stay in native
+ * `BedrockMessage[]`/`ConverseCommand` shape. A general, lossless
+ * `BedrockMessage` <-> `ModelMessage` converter is not attempted here, and
+ * would not be possible anyway: `BedrockToolResult` carries no `toolName`,
+ * which a faithful `ToolModelMessage` requires.
+ *
+ * Further scoped to TEXT-ONLY turns. A multimodal starting message (image,
+ * document, or — pathologically — a tool-use/tool-result block) skips
+ * wrapping entirely; the caller checks `isTextOnlyBedrockConversation` and
+ * falls back to calling the loop directly, logging that the turn was
+ * excluded. This mirrors the plan's AI Studio precedent: an excluded shape
+ * must be explicit in code, not implied by no test ever sending one.
+ *
+ * Who owns the outcome. When the wrapped `doGenerate`/`doStream` ran the loop,
+ * the loop's own result is authoritative for `finishReason`, `usage`,
+ * `toolExecutions` and the final conversation: a middleware may replace the
+ * content or the stream parts a caller sees, but it cannot rewrite the
+ * metadata of a turn that already reached the wire. When a middleware never
+ * calls through (a cache hit, a refusal, a synthetic answer) no loop ran, and
+ * its own V3 result is what gets reported.
+ */
+import type { ToolInputSchema } from "@aws-sdk/client-bedrock-runtime";
+import type { AgenticLoopChunk, BedrockMessage, LanguageModelV3CallOptions, LanguageModelV3StreamPart, ModelMessage } from "../../types/index.js";
+/** Names of the unsent options `params` carries; an empty list counts as unset. */
+export declare function unsentBedrockMiddlewareOptions(params: LanguageModelV3CallOptions): string[];
+/**
+ * Unwrap Bedrock's `ToolSpecification.inputSchema` — always `{ json:
+ * DocumentType }` on the wire (see `ToolInputSchema.JsonMember` in the AWS
+ * SDK), never the bare schema — to the plain JSON schema object the V3 tool
+ * shape's `inputSchema` field expects. `client.ts`'s own tool-formatting path
+ * (`formatToolsForBedrock`) always sends `{ json: schema }` to AWS for this
+ * exact reason; handing a middleware the wrapper itself instead of the
+ * schema breaks any schema-inspecting middleware (e.g. a guardrail
+ * validating tool arguments against the declared shape).
+ */
+export declare function unwrapBedrockToolInputSchema(inputSchema: ToolInputSchema | undefined): unknown;
+/** True when every content block of every message is plain text. */
+export declare function isTextOnlyBedrockConversation(conversation: BedrockMessage[]): boolean;
+/**
+ * `system` + the (already text-only) starting conversation, as a V3 prompt.
+ * The system prompt is always sent as its own leading message — Bedrock
+ * carries it out-of-band (`ConverseCommandInput.system`), but the V3 prompt
+ * shape has no separate slot, so `bedrockConversationFromV3Prompt` is the
+ * inverse that pulls it back out.
+ */
+export declare function buildV3PromptFromBedrock(systemPrompt: string, conversation: BedrockMessage[]): ModelMessage[];
+/**
+ * Inverse of `buildV3PromptFromBedrock`, read AFTER `transformParams` has
+ * run — this is what makes a middleware's prompt rewrite (correction 1)
+ * reach the wire: the caller passes the ORIGINAL prompt into `doGenerate`/
+ * `doStream`, and by AI SDK contract `transformParams` has already produced
+ * the version handed to the closure by the time this runs.
+ *
+ * A `tool` role message has no faithful Bedrock shape at this boundary (no
+ * toolUseId/toolName pairing survives `ToolModelMessage`), so one is
+ * dropped with a WARN rather than guessed at. The starting turn Bedrock
+ * ever hands across this boundary never contains one; seeing one here means
+ * middleware injected it.
+ */
+export declare function bedrockConversationFromV3Prompt(prompt: ModelMessage[]): {
+    system: string;
+    conversation: BedrockMessage[];
+};
+/**
+ * Wrap a native `AgenticLoopChunk` source into the V3 stream contract, one
+ * chunk at a time, forwarding cancellation to both the source iterator and
+ * `cancel` (which the caller wires to the turn's own `AbortController`, so
+ * breaking out of a wrapped stream tears down the underlying AWS SDK
+ * request — correction 4). `finish` resolves the terminal `finish` part
+ * once the loop settles; middleware inspecting the returned stream sees a
+ * genuine usage-bearing finish part even when nothing downstream reads it
+ * back out (a guardrail that blocks before calling `doStream` never
+ * produces this stream at all, which is the `!loopPromise` case its own
+ * caller handles).
+ */
+export declare function bedrockChunksToV3Stream(source: AsyncIterable<AgenticLoopChunk>, finish: Promise<LanguageModelV3StreamPart>, cancel: () => void): ReadableStream<LanguageModelV3StreamPart>;
+/**
+ * Inverse of `bedrockChunksToV3Stream`: drains a (possibly
+ * middleware-wrapped) V3 stream back into Bedrock's native chunk shape.
+ * `finish`/`error` parts are consumed here but not surfaced as chunks —
+ * `streamingConversationLoop` reads the turn's outcome from the loop's own
+ * `resultPromise`, which already carries richer usage/finishReason/
+ * toolExecutions than a V3 finish part does; this function exists only to
+ * satisfy the wrapped stream's own contract (a middleware may expect its
+ * returned stream to be drained to completion) and to `throw` a middleware
+ * `error` part into the consumer.
+ */
+export declare function bedrockV3StreamToChunks(stream: ReadableStream<LanguageModelV3StreamPart>): AsyncIterable<AgenticLoopChunk>;

package/dist/providers/amazonBedrock/modelBridge.js

@@ -0,0 +1,226 @@
+/**
+ * Bridges Bedrock's native `BedrockMessage[]` conversation shape and
+ * `AgenticLoopChunk` stream to the AI SDK V3 model-middleware protocol
+ * (`LanguageModelV3`), so `BaseProvider.applyMiddlewareToModel()` can wrap a
+ * turn built entirely out of `runAgenticLoop` — the same engine Bedrock's
+ * `generate()` and `executeStream()` already run on.
+ *
+ * Scope: only the conversation `generate()`/`executeStream()` hand to the
+ * loop as its STARTING point ever crosses this boundary. Both reset
+ * `conversationHistory` to a single fresh message before calling the loop
+ * (see `client.ts`), so that starting point is always `system + one user
+ * message` — never prior assistant/tool-result turns, which are constructed
+ * entirely inside the loop's own steps and stay in native
+ * `BedrockMessage[]`/`ConverseCommand` shape. A general, lossless
+ * `BedrockMessage` <-> `ModelMessage` converter is not attempted here, and
+ * would not be possible anyway: `BedrockToolResult` carries no `toolName`,
+ * which a faithful `ToolModelMessage` requires.
+ *
+ * Further scoped to TEXT-ONLY turns. A multimodal starting message (image,
+ * document, or — pathologically — a tool-use/tool-result block) skips
+ * wrapping entirely; the caller checks `isTextOnlyBedrockConversation` and
+ * falls back to calling the loop directly, logging that the turn was
+ * excluded. This mirrors the plan's AI Studio precedent: an excluded shape
+ * must be explicit in code, not implied by no test ever sending one.
+ *
+ * Who owns the outcome. When the wrapped `doGenerate`/`doStream` ran the loop,
+ * the loop's own result is authoritative for `finishReason`, `usage`,
+ * `toolExecutions` and the final conversation: a middleware may replace the
+ * content or the stream parts a caller sees, but it cannot rewrite the
+ * metadata of a turn that already reached the wire. When a middleware never
+ * calls through (a cache hit, a refusal, a synthetic answer) no loop ran, and
+ * its own V3 result is what gets reported.
+ */
+import { logger } from "../../utils/logger.js";
+/**
+ * Sampling and output-shaping options of a V3 call that Converse is never
+ * sent: both turn builders fill `inferenceConfig` with `maxTokens` and
+ * `temperature` alone. The bridge seeds none of these, so a value present
+ * when `doGenerate`/`doStream` runs was put there by a middleware, and would
+ * otherwise be dropped without a trace.
+ */
+const UNSENT_V3_OPTIONS = [
+    "topP",
+    "topK",
+    "presencePenalty",
+    "frequencyPenalty",
+    "stopSequences",
+    "seed",
+    "toolChoice",
+    "responseFormat",
+];
+/** Names of the unsent options `params` carries; an empty list counts as unset. */
+export function unsentBedrockMiddlewareOptions(params) {
+    return UNSENT_V3_OPTIONS.filter((key) => {
+        const value = params[key];
+        return Array.isArray(value) ? value.length > 0 : value !== undefined;
+    });
+}
+/**
+ * Unwrap Bedrock's `ToolSpecification.inputSchema` — always `{ json:
+ * DocumentType }` on the wire (see `ToolInputSchema.JsonMember` in the AWS
+ * SDK), never the bare schema — to the plain JSON schema object the V3 tool
+ * shape's `inputSchema` field expects. `client.ts`'s own tool-formatting path
+ * (`formatToolsForBedrock`) always sends `{ json: schema }` to AWS for this
+ * exact reason; handing a middleware the wrapper itself instead of the
+ * schema breaks any schema-inspecting middleware (e.g. a guardrail
+ * validating tool arguments against the declared shape).
+ */
+export function unwrapBedrockToolInputSchema(inputSchema) {
+    return inputSchema && "json" in inputSchema ? inputSchema.json : undefined;
+}
+/** True when every content block of every message is plain text. */
+export function isTextOnlyBedrockConversation(conversation) {
+    return conversation.every((message) => message.content.every((block) => block.text !== undefined &&
+        block.image === undefined &&
+        block.document === undefined &&
+        block.toolUse === undefined &&
+        block.toolResult === undefined));
+}
+/**
+ * `system` + the (already text-only) starting conversation, as a V3 prompt.
+ * The system prompt is always sent as its own leading message — Bedrock
+ * carries it out-of-band (`ConverseCommandInput.system`), but the V3 prompt
+ * shape has no separate slot, so `bedrockConversationFromV3Prompt` is the
+ * inverse that pulls it back out.
+ */
+export function buildV3PromptFromBedrock(systemPrompt, conversation) {
+    const prompt = [{ role: "system", content: systemPrompt }];
+    for (const message of conversation) {
+        const text = message.content.map((block) => block.text ?? "").join("");
+        if (message.role === "user") {
+            prompt.push({ role: "user", content: text });
+        }
+        else {
+            prompt.push({ role: "assistant", content: text });
+        }
+    }
+    return prompt;
+}
+function contentToText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    return content
+        .filter((part) => typeof part === "object" && part !== null && part.type === "text")
+        .map((part) => part.text)
+        .join("");
+}
+/**
+ * Inverse of `buildV3PromptFromBedrock`, read AFTER `transformParams` has
+ * run — this is what makes a middleware's prompt rewrite (correction 1)
+ * reach the wire: the caller passes the ORIGINAL prompt into `doGenerate`/
+ * `doStream`, and by AI SDK contract `transformParams` has already produced
+ * the version handed to the closure by the time this runs.
+ *
+ * A `tool` role message has no faithful Bedrock shape at this boundary (no
+ * toolUseId/toolName pairing survives `ToolModelMessage`), so one is
+ * dropped with a WARN rather than guessed at. The starting turn Bedrock
+ * ever hands across this boundary never contains one; seeing one here means
+ * middleware injected it.
+ */
+export function bedrockConversationFromV3Prompt(prompt) {
+    const systemParts = [];
+    const conversation = [];
+    for (const message of prompt) {
+        if (message.role === "system") {
+            systemParts.push(message.content);
+            continue;
+        }
+        if (message.role === "tool") {
+            logger.warn("[AmazonBedrockProvider] middleware transformParams introduced a 'tool' role message; it has no Bedrock wire shape at this boundary and was dropped");
+            continue;
+        }
+        conversation.push({
+            role: message.role,
+            content: [{ text: contentToText(message.content) }],
+        });
+    }
+    return { system: systemParts.join("\n\n"), conversation };
+}
+/**
+ * Wrap a native `AgenticLoopChunk` source into the V3 stream contract, one
+ * chunk at a time, forwarding cancellation to both the source iterator and
+ * `cancel` (which the caller wires to the turn's own `AbortController`, so
+ * breaking out of a wrapped stream tears down the underlying AWS SDK
+ * request — correction 4). `finish` resolves the terminal `finish` part
+ * once the loop settles; middleware inspecting the returned stream sees a
+ * genuine usage-bearing finish part even when nothing downstream reads it
+ * back out (a guardrail that blocks before calling `doStream` never
+ * produces this stream at all, which is the `!loopPromise` case its own
+ * caller handles).
+ */
+export function bedrockChunksToV3Stream(source, finish, cancel) {
+    const iterator = source[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const next = await iterator.next();
+                if (next.done) {
+                    controller.enqueue(await finish);
+                    controller.close();
+                }
+                else if (next.value.reasoning) {
+                    controller.enqueue({
+                        type: "reasoning-delta",
+                        delta: next.value.reasoning,
+                    });
+                }
+                else {
+                    controller.enqueue({ type: "text-delta", delta: next.value.content });
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        async cancel() {
+            cancel();
+            await iterator.return?.();
+        },
+    });
+}
+/**
+ * Inverse of `bedrockChunksToV3Stream`: drains a (possibly
+ * middleware-wrapped) V3 stream back into Bedrock's native chunk shape.
+ * `finish`/`error` parts are consumed here but not surfaced as chunks —
+ * `streamingConversationLoop` reads the turn's outcome from the loop's own
+ * `resultPromise`, which already carries richer usage/finishReason/
+ * toolExecutions than a V3 finish part does; this function exists only to
+ * satisfy the wrapped stream's own contract (a middleware may expect its
+ * returned stream to be drained to completion) and to `throw` a middleware
+ * `error` part into the consumer.
+ */
+export async function* bedrockV3StreamToChunks(stream) {
+    const reader = stream.getReader();
+    let done = false;
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done) {
+                done = true;
+                return;
+            }
+            const part = next.value;
+            if (part.type === "text-delta") {
+                yield { content: part.delta };
+            }
+            else if (part.type === "reasoning-delta") {
+                yield { content: "", reasoning: part.delta };
+            }
+            else if (part.type === "error") {
+                throw part.error;
+            }
+        }
+    }
+    finally {
+        try {
+            if (!done) {
+                await reader.cancel();
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}

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

@@ -271,6 +271,26 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * this for free via the AI SDK `wrapStream` middleware; native @google/genai
      * bypasses that wrapper, so native consumers need their lifecycle
      * callbacks invoked from here.
+     *
+     * `BaseProvider.stream()` always passes the result this method returns
+     * through `wrapStreamWithLifecycleCallbacks` afterwards too (that wrapper
+     * has "no early return when there are no callbacks" — see its own doc
+     * comment) — so unconditionally firing here double-fires onChunk/onFinish
+     * for every native Vertex stream. `isLifecycleStreamCallbacksOwnedByBaseProvider`
+     * reads the SAME nested lifecycle config off the SAME `options` object
+     * `wrapStreamWithLifecycleCallbacks` reads from (NeuroLink.applyStreamLifecycleMiddleware
+     * stamps it before either method runs), so both sites agree on which one
+     * actually fires without a second, Vertex-specific marker — and without
+     * relying on a Symbol on the `StreamResult` itself, which would not
+     * survive `withStreamModelFallback`'s rebuild of a plain forwarding object
+     * between this method and `wrapStreamWithLifecycleCallbacks`.
+     *
+     * onError is deliberately NOT gated by that marker — same precedent as
+     * `middleware/builtin/lifecycle.ts`'s `wrapStream` ("onError is NOT
+     * covered by this flag: it keeps its own, independent dedup via
+     * fireOnErrorOnce's shared fired-marker"). `fireOnErrorOnce` stamps the
+     * error so `BaseProvider`'s own catch (which checks
+     * `hasLifecycleErrorFired`) skips its own fire for the same failure.
      */
     private wrapStreamResultWithLifecycle;
     /**

package/dist/providers/googleVertex/client.js

@@ -22,6 +22,7 @@ import { FileDetector } from "../../utils/fileDetector.js";
 import { mergeMediaFileAliases, normalizeVisionImageFormats, processUnifiedFilesArray, } from "../../utils/messageBuilder.js";
 import { logger } from "../../utils/logger.js";
 import { drainDetachedPump } from "../../utils/drainDetachedPump.js";
+import { fireOnErrorOnce, getLifecycleMiddlewareConfig, isLifecycleStreamCallbacksOwnedByBaseProvider, } from "../../utils/lifecycleCallbacks.js";
 import { GEMINI_ELISION_NOTE, planGeminiLoopReclaim, previewGeminiToolResponseText, } from "../../context/geminiLoopGuard.js";
 import { ANTHROPIC_ELISION_NOTE, planAnthropicLoopReclaim, previewAnthropicToolResultText, } from "../../context/anthropicLoopGuard.js";
 import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, toVertexAnthropicModelId, } from "../../utils/modelDetection.js";
@@ -5618,24 +5619,47 @@ export class GoogleVertexProvider extends BaseProvider {
      * this for free via the AI SDK `wrapStream` middleware; native @google/genai
      * bypasses that wrapper, so native consumers need their lifecycle
      * callbacks invoked from here.
+     *
+     * `BaseProvider.stream()` always passes the result this method returns
+     * through `wrapStreamWithLifecycleCallbacks` afterwards too (that wrapper
+     * has "no early return when there are no callbacks" — see its own doc
+     * comment) — so unconditionally firing here double-fires onChunk/onFinish
+     * for every native Vertex stream. `isLifecycleStreamCallbacksOwnedByBaseProvider`
+     * reads the SAME nested lifecycle config off the SAME `options` object
+     * `wrapStreamWithLifecycleCallbacks` reads from (NeuroLink.applyStreamLifecycleMiddleware
+     * stamps it before either method runs), so both sites agree on which one
+     * actually fires without a second, Vertex-specific marker — and without
+     * relying on a Symbol on the `StreamResult` itself, which would not
+     * survive `withStreamModelFallback`'s rebuild of a plain forwarding object
+     * between this method and `wrapStreamWithLifecycleCallbacks`.
+     *
+     * onError is deliberately NOT gated by that marker — same precedent as
+     * `middleware/builtin/lifecycle.ts`'s `wrapStream` ("onError is NOT
+     * covered by this flag: it keeps its own, independent dedup via
+     * fireOnErrorOnce's shared fired-marker"). `fireOnErrorOnce` stamps the
+     * error so `BaseProvider`'s own catch (which checks
+     * `hasLifecycleErrorFired`) skips its own fire for the same failure.
      */
     wrapStreamResultWithLifecycle(options, result, startTime) {
         const onChunk = options.onChunk;
         const onFinish = options
             .onFinish;
-        const onError = options
-            .onError;
+        // `StreamOptions.onError` is already properly typed as `OnErrorCallback`
+        // (unlike the two casts above, kept from before that field existed on
+        // the type) — read directly so `fireOnErrorOnce` below gets it without
+        // a cast.
+        const onError = options.onError;
         if (typeof onChunk !== "function" &&
             typeof onFinish !== "function" &&
             typeof onError !== "function") {
             return result;
         }
+        const streamCallbacksOwnedByBaseProvider = isLifecycleStreamCallbacksOwnedByBaseProvider(getLifecycleMiddlewareConfig(options));
         const originalIterable = result.stream;
         let accumulated = "";
         let sequence = 0;
-        const provider = this.providerName;
         const fireOnChunk = (payload) => {
-            if (typeof onChunk !== "function") {
+            if (typeof onChunk !== "function" || streamCallbacksOwnedByBaseProvider) {
                 return;
             }
             try {
@@ -5647,7 +5671,8 @@ export class GoogleVertexProvider extends BaseProvider {
             }
         };
         const fireOnFinish = (payload) => {
-            if (typeof onFinish !== "function") {
+            if (typeof onFinish !== "function" ||
+                streamCallbacksOwnedByBaseProvider) {
                 return;
             }
             try {
@@ -5686,21 +5711,18 @@ export class GoogleVertexProvider extends BaseProvider {
                     });
                 }
                 catch (err) {
-                    if (typeof onError === "function") {
-                        try {
-                            const errInst = err instanceof Error ? err : new Error(String(err));
-                            const cbResult = onError({
-                                error: errInst,
-                                duration: Date.now() - startTime,
-                                recoverable: false,
-                            });
-                            Promise.resolve(cbResult).catch((e) => logger.warn(`[${provider}] onError callback rejected: ${e instanceof Error ? e.message : String(e)}`));
-                        }
-                        catch (e) {
-                            logger.warn(`[${provider}] onError callback threw: ${e instanceof Error ? e.message : String(e)}`);
-                        }
-                    }
-                    throw err;
+                    const errInst = err instanceof Error ? err : new Error(String(err));
+                    fireOnErrorOnce(onError, errInst, {
+                        error: errInst,
+                        duration: Date.now() - startTime,
+                        recoverable: false,
+                    });
+                    // Rethrow the normalized `errInst` (not the raw `err`) so the
+                    // fired-mark `fireOnErrorOnce` just stamped on it propagates to
+                    // BaseProvider's own catch (`hasLifecycleErrorFired`), which
+                    // would otherwise see an unstamped error and fire onError again
+                    // for the same logical failure.
+                    throw errInst;
                 }
             },
         };

package/dist/utils/lifecycleCallbacks.d.ts

@@ -27,7 +27,36 @@
  * structuredClone / cross-realm postMessage where a closed-over
  * WeakSet does not.
  */
-import type { LifecycleErrorPayload, OnErrorCallback } from "../types/index.js";
+import type { LifecycleErrorPayload, LifecycleMiddlewareConfig, OnErrorCallback } from "../types/index.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.
+ *
+ * Shared (moved out of `BaseProvider`) because two independent firing sites
+ * now need the same read: `BaseProvider.wrapStreamWithLifecycleCallbacks`
+ * (every provider's stream) and `GoogleVertexProvider.wrapStreamResultWithLifecycle`
+ * (Vertex's own native-stream firer, which must check the SAME
+ * `isLifecycleStreamCallbacksOwnedByBaseProvider` marker on the SAME nested
+ * config object that BaseProvider's wrapper reads from `options`, so that
+ * both sites agree on who owns firing without a second marker).
+ */
+export declare function getLifecycleMiddlewareConfig(options: unknown): LifecycleMiddlewareConfig | undefined;
+/**
+ * Stamp a stream lifecycle config object with
+ * `STREAM_CALLBACKS_OWNED_BY_BASE_PROVIDER`. See that symbol's doc comment
+ * for who may call this (only `applyStreamLifecycleMiddleware`) and why.
+ */
+export declare function markLifecycleStreamCallbacksOwnedByBaseProvider(config: object): void;
+/**
+ * True when `markLifecycleStreamCallbacksOwnedByBaseProvider` already
+ * stamped this config. The model-level lifecycle middleware reads this to
+ * decide whether to fire its own onChunk/onFinish for a stream config.
+ */
+export declare function isLifecycleStreamCallbacksOwnedByBaseProvider(config: unknown): boolean;
 /**
  * Returns true when `markLifecycleErrorFired` or a previous
  * `fireOnErrorOnce` call has already stamped this error.

package/dist/utils/lifecycleCallbacks.js

@@ -28,6 +28,99 @@
  * WeakSet does not.
  */
 const ON_ERROR_FIRED = Symbol.for("neurolink.onErrorFired");
+/**
+ * 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.
+ *
+ * Shared (moved out of `BaseProvider`) because two independent firing sites
+ * now need the same read: `BaseProvider.wrapStreamWithLifecycleCallbacks`
+ * (every provider's stream) and `GoogleVertexProvider.wrapStreamResultWithLifecycle`
+ * (Vertex's own native-stream firer, which must check the SAME
+ * `isLifecycleStreamCallbacksOwnedByBaseProvider` marker on the SAME nested
+ * config object that BaseProvider's wrapper reads from `options`, so that
+ * both sites agree on who owns firing without a second marker).
+ */
+export function getLifecycleMiddlewareConfig(options) {
+    return options?.middleware
+        ?.middlewareConfig?.lifecycle?.config;
+}
+/**
+ * Marks a stream lifecycle config as "BaseProvider.wrapStreamWithLifecycleCallbacks
+ * already fires onChunk/onFinish for this config, authoritatively, from
+ * NeuroLink's own normalized stream — the model-level lifecycle middleware
+ * (middleware/builtin/lifecycle.ts) must not ALSO fire them from the raw
+ * per-provider V3 chunks it sees."
+ *
+ * Only `NeuroLink.applyStreamLifecycleMiddleware()` stamps a config with this
+ * marker, and only for stream()'s config: it is the one function that builds
+ * a lifecycle config fresh from stream()'s top-level onChunk/onFinish/onError
+ * options, for a call that unconditionally passes through
+ * `BaseProvider.wrapStreamWithLifecycleCallbacks` afterwards — see that
+ * method's doc comment ("the only point every provider's stream passes
+ * through unconditionally"). Without this marker both layers fire
+ * onChunk/onFinish for the same logical stream: once (unreliable, raw,
+ * provider-shape-dependent) from the model-level middleware, once (reliable,
+ * normalized) from BaseProvider.
+ *
+ * `NeuroLink.applyGenerateLifecycleMiddleware()` must NEVER stamp its config
+ * this way. BaseProvider has no equivalent guaranteed-delivery layer for
+ * generate()'s onFinish: `BaseProvider.finalizeNativeGenerate`'s own doc
+ * comment states onFinish is deliberately NOT fired there because "the
+ * native paths now wrap their model, so the lifecycle middleware fires it" —
+ * the model-level middleware is the SOLE firing site for every native
+ * generate loop that goes through the model wrap (sagemaker,
+ * openaiChatCompletionsBase, anthropic). The one generate path that bypasses
+ * the model wrap (GoogleVertex's native @google/genai loop) fires onFinish
+ * itself via `BaseProvider.fireGenerateOnFinish` precisely because the
+ * middleware never runs for it. Stamping the generate config would make the
+ * model-level middleware suppress its own firing with nothing left to fire
+ * it, silently breaking onFinish for every one of those providers.
+ *
+ * A config a consumer builds directly — e.g. calling the exported
+ * `createLifecycleMiddleware` and applying it to their own model via the
+ * `ai` package's `wrapLanguageModel`, entirely outside NeuroLink's
+ * BaseProvider/stream()/generate() call path — is never stamped, so that
+ * standalone use keeps firing onChunk/onFinish exactly as before (CLAUDE.md
+ * rule 5: public SDK API must not break existing callers).
+ *
+ * Symbol-stamped on the object itself (not a typed field) for the same
+ * reason as `ON_ERROR_FIRED` above: it survives across separate module
+ * copies of the same config object where a closed-over WeakSet would not.
+ */
+const STREAM_CALLBACKS_OWNED_BY_BASE_PROVIDER = Symbol.for("neurolink.lifecycleStreamCallbacksOwnedByBaseProvider");
+/**
+ * Stamp a stream lifecycle config object with
+ * `STREAM_CALLBACKS_OWNED_BY_BASE_PROVIDER`. See that symbol's doc comment
+ * for who may call this (only `applyStreamLifecycleMiddleware`) and why.
+ */
+export function markLifecycleStreamCallbacksOwnedByBaseProvider(config) {
+    try {
+        Object.defineProperty(config, STREAM_CALLBACKS_OWNED_BY_BASE_PROVIDER, {
+            value: true,
+            enumerable: false,
+            writable: false,
+            configurable: false,
+        });
+    }
+    catch {
+        // Non-extensible config object — worst case is the pre-fix double fire.
+    }
+}
+/**
+ * True when `markLifecycleStreamCallbacksOwnedByBaseProvider` already
+ * stamped this config. The model-level lifecycle middleware reads this to
+ * decide whether to fire its own onChunk/onFinish for a stream config.
+ */
+export function isLifecycleStreamCallbacksOwnedByBaseProvider(config) {
+    if (config === null || typeof config !== "object") {
+        return false;
+    }
+    return (config[STREAM_CALLBACKS_OWNED_BY_BASE_PROVIDER] === true);
+}
 function stampFired(error) {
     try {
         Object.defineProperty(error, ON_ERROR_FIRED, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.41.3",
+  "version": "12.41.5",
   "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": {