@juspay/neurolink 12.12.5 → 12.12.6

package/dist/core/baseProvider.d.ts

@@ -468,6 +468,16 @@ export declare abstract class BaseProvider implements AIProvider {
      * TODO(#1576): Implement global level middlewares that can be used
      */
     protected getAISDKModelWithMiddleware(options?: TextGenerationOptions | StreamOptions): Promise<LanguageModel>;
+    /**
+     * Apply the configured middleware chain to a caller-supplied base model.
+     *
+     * `getAISDKModelWithMiddleware()` always wraps `getAISDKModel()`, which is
+     * the model the non-streaming path drives. Streaming paths build a
+     * different base — one whose `doStream` starts the provider's own stream
+     * loop — and need the same chain applied to it, so the wrapping is split
+     * out here rather than duplicated per provider.
+     */
+    protected applyMiddlewareToModel(baseModel: LanguageModel, options?: TextGenerationOptions | StreamOptions): Promise<LanguageModel>;
     /**
      * Extract middleware options - delegated to Utilities
      */

package/dist/core/baseProvider.js

@@ -2014,8 +2014,18 @@ export class BaseProvider {
      * TODO(#1576): Implement global level middlewares that can be used
      */
     async getAISDKModelWithMiddleware(options = {}) {
-        // Get the base model
-        const baseModel = await this.getAISDKModel();
+        return this.applyMiddlewareToModel(await this.getAISDKModel(), options);
+    }
+    /**
+     * Apply the configured middleware chain to a caller-supplied base model.
+     *
+     * `getAISDKModelWithMiddleware()` always wraps `getAISDKModel()`, which is
+     * the model the non-streaming path drives. Streaming paths build a
+     * different base — one whose `doStream` starts the provider's own stream
+     * loop — and need the same chain applied to it, so the wrapping is split
+     * out here rather than duplicated per provider.
+     */
+    async applyMiddlewareToModel(baseModel, options = {}) {
         logger.debug(`Retrieved base model for ${this.providerName}`, {
             provider: this.providerName,
             model: this.modelName,

package/dist/middleware/builtin/guardrails.js

@@ -43,7 +43,6 @@ export function createGuardrailsMiddleware(config = {}) {
     const blockingState = new WeakMap();
     const middleware = {
         specificationVersion: "v3",
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         transformParams: async ({ params }) => {
             if (config.precallEvaluation?.enabled) {
                 const { shouldBlock, transformedParams } = await handlePrecallGuardrails(params, config.precallEvaluation);
@@ -53,7 +52,6 @@ export function createGuardrailsMiddleware(config = {}) {
             }
             return params;
         },
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         wrapGenerate: async ({ doGenerate, params }) => {
             logger.debug(`[GuardrailsMiddleware] Applying to generate call.`);
             // Check if this request should be blocked (set by transformParams)
@@ -61,14 +59,23 @@ export function createGuardrailsMiddleware(config = {}) {
                 return createBlockedResponse();
             }
             let result = await doGenerate();
-            const filterResult = applyContentFiltering(result.text || "", config.badWords, "generate");
-            if (filterResult.hasChanges) {
-                result = { ...result, text: filterResult.filteredText };
-            }
+            result = {
+                ...result,
+                content: result.content.map((part) => part.type === "text"
+                    ? {
+                        ...part,
+                        text: applyContentFiltering(part.text, config.badWords, "generate").filteredText,
+                    }
+                    : part),
+            };
             if (config.modelFilter?.enabled && config.modelFilter.filterModel) {
                 logger.debug(`[GuardrailsMiddleware] Invoking model-based filter.`);
                 try {
-                    const filterPrompt = `Is the following text safe? Respond with only "safe" or "unsafe".\n\nText: "${result.text}"`;
+                    const text = result.content
+                        .filter((part) => part.type === "text")
+                        .map((part) => part.text)
+                        .join("");
+                    const filterPrompt = `Is the following text safe? Respond with only "safe" or "unsafe".\n\nText: "${text}"`;
                     // `ModelFilterConfig.filterModel` is typed `LanguageModel`, which
                     // admits a bare model id, and the documented examples used one.
                     // `generateOnceNative` needs a handle exposing doGenerate, so a
@@ -78,7 +85,12 @@ export function createGuardrailsMiddleware(config = {}) {
                     const { text: filterResponse } = await generateOnceNative(filterModel, { prompt: filterPrompt });
                     if (filterResponse.toLowerCase().trim() === "unsafe") {
                         logger.warn(`[GuardrailsMiddleware] Model-based filter flagged content as unsafe.`);
-                        result = { ...result, text: "<REDACTED BY AI GUARDRAIL>" };
+                        result = {
+                            ...result,
+                            content: result.content.map((part) => part.type === "text"
+                                ? { ...part, text: "<REDACTED BY AI GUARDRAIL>" }
+                                : part),
+                        };
                     }
                 }
                 catch (error) {
@@ -89,7 +101,6 @@ export function createGuardrailsMiddleware(config = {}) {
             }
             return result;
         },
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         wrapStream: async ({ doStream, params }) => {
             logger.debug(`[GuardrailsMiddleware] Applying to stream call.`);
             // Check if this request should be blocked (set by transformParams)
@@ -106,13 +117,12 @@ export function createGuardrailsMiddleware(config = {}) {
                 transform(chunk, controller) {
                     hasYieldedChunks = true;
                     let filteredChunk = chunk;
-                    if (typeof filteredChunk === "object" &&
-                        "textDelta" in filteredChunk) {
-                        const filterResult = applyContentFiltering(filteredChunk.textDelta, config.badWords, "stream");
+                    if (filteredChunk.type === "text-delta") {
+                        const filterResult = applyContentFiltering(filteredChunk.delta, config.badWords, "stream");
                         if (filterResult.hasChanges) {
                             filteredChunk = {
                                 ...filteredChunk,
-                                textDelta: filterResult.filteredText,
+                                delta: filterResult.filteredText,
                             };
                         }
                     }

package/dist/middleware/utils/guardrailsUtils.d.ts

@@ -1,4 +1,4 @@
-import type { BadWordsConfig, ContentFilteringResult, EvaluationActionResult, PrecallEvaluationConfig, PrecallEvaluationResult } from "../../types/index.js";
+import type { BadWordsConfig, LanguageModelV3GenerateResult, LanguageModelV3StreamPart, ContentFilteringResult, EvaluationActionResult, PrecallEvaluationConfig, PrecallEvaluationResult } from "../../types/index.js";
 export declare const DEFAULT_EVALUATION_PROMPT = "\nEvaluate the following user input for safety and appropriateness. Respond ONLY with valid JSON:\n\n{\n  \"overall\": \"safe|unsafe|suspicious|inappropriate\",\n  \"safetyScore\": <1-10>,\n  \"appropriatenessScore\": <1-10>,\n  \"confidenceLevel\": <1-10>,\n  \"issues\": [\n    {\n      \"category\": \"explicit_content|hate_speech|violence|personal_info|spam|other\",\n      \"severity\": \"low|medium|high|critical\",\n      \"description\": \"Brief description\"\n    }\n  ],\n  \"suggestedAction\": \"allow|block|sanitize|warn\",\n  \"reasoning\": \"Brief explanation\"\n}\n\nUser Input: \"{USER_INPUT}\"\n";
 /**
  * Extract user input from middleware params
@@ -25,20 +25,8 @@ export declare function applyEvaluationActions(evaluation: PrecallEvaluationResu
  */
 export declare function applySanitization(params: any, sanitizedInput: string): any;
 export declare function escapeRegExp(string: string): string;
-export declare function createBlockedResponse(): {
-    text: string;
-    usage: {
-        promptTokens: number;
-        completionTokens: number;
-    };
-    finishReason: "stop";
-    warnings: never[];
-    rawCall: {
-        rawPrompt: null;
-        rawSettings: {};
-    };
-};
-export declare function createBlockedStream(): ReadableStream<any>;
+export declare function createBlockedResponse(): LanguageModelV3GenerateResult;
+export declare function createBlockedStream(): ReadableStream<LanguageModelV3StreamPart>;
 /**
  * Apply content filtering using bad words configuration
  * Handles both regex patterns and string lists with proper priority

package/dist/middleware/utils/guardrailsUtils.js

@@ -258,24 +258,31 @@ export function escapeRegExp(string) {
 }
 export function createBlockedResponse() {
     return {
-        text: "Request contains inappropriate content and has been blocked.",
-        usage: { promptTokens: 0, completionTokens: 0 },
-        finishReason: "stop",
+        content: [
+            {
+                type: "text",
+                text: "Request contains inappropriate content and has been blocked.",
+            },
+        ],
+        usage: { inputTokens: { total: 0 }, outputTokens: { total: 0 } },
+        finishReason: { unified: "stop" },
         warnings: [],
-        rawCall: { rawPrompt: null, rawSettings: {} },
     };
 }
 export function createBlockedStream() {
     return new ReadableStream({
         start(controller) {
+            controller.enqueue({ type: "text-start", id: "blocked" });
             controller.enqueue({
                 type: "text-delta",
-                textDelta: "Request contains inappropriate content and has been blocked.",
+                id: "blocked",
+                delta: "Request contains inappropriate content and has been blocked.",
             });
+            controller.enqueue({ type: "text-end", id: "blocked" });
             controller.enqueue({
                 type: "finish",
-                finishReason: "stop",
-                usage: { promptTokens: 0, completionTokens: 0 },
+                finishReason: { unified: "stop" },
+                usage: { inputTokens: { total: 0 }, outputTokens: { total: 0 } },
             });
             controller.close();
         },

package/dist/middleware/wrapLanguageModel.d.ts

@@ -6,10 +6,9 @@
  * `wrapGenerate` / `wrapStream` hooks. Reproduced here so the middleware
  * factory no longer needs the ai package.
  *
- * Worth recording: `wrapStream` does not currently run in this codebase. Every
- * streaming path is native and bypasses the wrapped model entirely, so only
- * `wrapGenerate` is reachable. That is a pre-existing gap, not one this
- * introduced.
+ * The OpenAI-compatible streaming path also uses this wrapper. Other native
+ * streaming implementations must opt in explicitly; exposing a middleware
+ * option or a model-shaped handle alone does not apply the chain.
  */
 import type { LanguageModelV3, LanguageModelV3Middleware } from "../types/index.js";
 export declare const wrapLanguageModel: ({ model, middleware, }: {

package/dist/middleware/wrapLanguageModel.js

@@ -6,10 +6,9 @@
  * `wrapGenerate` / `wrapStream` hooks. Reproduced here so the middleware
  * factory no longer needs the ai package.
  *
- * Worth recording: `wrapStream` does not currently run in this codebase. Every
- * streaming path is native and bypasses the wrapped model entirely, so only
- * `wrapGenerate` is reachable. That is a pre-existing gap, not one this
- * introduced.
+ * The OpenAI-compatible streaming path also uses this wrapper. Other native
+ * streaming implementations must opt in explicitly; exposing a middleware
+ * option or a model-shaped handle alone does not apply the chain.
  */
 const doWrap = (model, middleware) => {
     const transform = async (params, type) => middleware.transformParams

package/dist/providers/openaiChatCompletionsBase.js

@@ -66,6 +66,73 @@ const yieldsSchemaValidObject = (text, schema) => {
     const coerced = coerceJsonToSchema(text, schema);
     return coerced !== null && schemaAccepts(schema, coerced.structuredData);
 };
+// Pull one native chunk at a time and forward cancellation to its iterator.
+const chunksToV3Stream = (source, completion, cancel) => {
+    const iterator = source[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const next = await iterator.next();
+                if (next.done) {
+                    controller.enqueue(await completion);
+                    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?.();
+        },
+    });
+};
+async function* v3StreamToChunks(stream, onFinish) {
+    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 === "finish") {
+                onFinish(part);
+            }
+            else if (part.type === "error") {
+                throw part.error;
+            }
+        }
+    }
+    finally {
+        try {
+            if (!done) {
+                await reader.cancel();
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}
 export class OpenAIChatCompletionsProvider extends BaseProvider {
     config;
     resolvedModel;
@@ -946,7 +1013,10 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         let wireNameMaps;
         let openAITools;
         let openAIToolChoice;
-        let conversation;
+        // The prompt is kept in its pre-wire shape. Model middleware transforms
+        // `params.prompt`, and the conversion to the chat-completions wire format
+        // has to happen AFTER that or the transform would be discarded.
+        let promptMessages;
         try {
             modelId = await this.resolveModelName();
             const shouldUseTools = !options.disableTools && this.supportsTools();
@@ -962,8 +1032,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 ? buildToolsForOpenAI(toolsRecord, wireNameMaps?.toWire)
                 : undefined;
             openAIToolChoice = mapNeuroLinkToolChoice(resolveToolChoice(options, toolsRecord, shouldUseTools), wireNameMaps?.toWire);
-            const initialMessages = await this.buildMessagesForStream(options);
-            conversation = messageBuilderToOpenAI(initialMessages, wireNameMaps?.toWire);
+            promptMessages = (await this.buildMessagesForStream(options));
         }
         catch (setupErr) {
             timeoutController?.cleanup();
@@ -979,26 +1048,136 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         const channel = createStreamChannel();
         // Per-provider lifecycle hook (e.g. OTel span wrap for LiteLLM).
         const lifecycle = this.onStreamStart(modelId);
-        const loopPromise = this.runStreamLoop({
-            maxSteps,
+        // Model middleware on the streaming path.
+        //
+        // The base model below is not `buildDelegatingModel()`'s — that one's
+        // `doGenerate` is a single wire call and its `doStream` is a stub. This
+        // one's `doStream` starts the real multi-step stream loop, which is what
+        // "produce the stream for this request" means here. Wrapping it gives the
+        // streaming path the contract the generate path has always had:
+        // `transformParams` can rewrite the prompt before a byte is sent, and
+        // `wrapStream` can observe, filter, or replace the stream outright.
+        //
+        // Honoured on the way back in: `prompt`, `maxOutputTokens`, `temperature`
+        // and `topP`. `tools` is offered read-only — a middleware that rewrites it
+        // gets a WARN rather than a silent drop, because re-deriving the wire tool
+        // list here would diverge from `buildToolsForOpenAI`.
+        const v3Tools = openAITools?.map((t) => ({
+            type: "function",
+            name: t.function.name,
+            description: t.function.description,
+            inputSchema: t.function.parameters,
+        }));
+        const v3Params = {
+            prompt: promptMessages,
+            ...(v3Tools ? { tools: v3Tools } : {}),
+            ...(options.maxTokens !== undefined
+                ? { maxOutputTokens: options.maxTokens }
+                : {}),
+            ...(options.temperature !== undefined
+                ? { temperature: options.temperature }
+                : {}),
+            ...(options.topP !== undefined ? { topP: options.topP } : {}),
+        };
+        let loopPromise;
+        const providerNameForLoop = this.providerName;
+        const streamBaseModel = {
+            specificationVersion: "v3",
+            provider: providerNameForLoop,
             modelId,
-            url,
-            fetchImpl,
-            abortSignal,
-            options,
-            conversation,
-            openAITools,
-            openAIToolChoice,
-            toolsRecord,
-            toolNameFromWire: wireNameMaps?.fromWire,
-            emitter,
-            toolsUsed,
-            toolExecutionSummaries,
-            pushChunk: channel.push,
-            closeChannel: channel.close,
-            resolveUsage,
-            resolveFinish,
-        });
+            supportedUrls: {},
+            doGenerate: async (params) => {
+                const model = await this.getAISDKModel();
+                if (typeof model === "string") {
+                    throw new Error("Native model handle required");
+                }
+                return model.doGenerate(params);
+            },
+            doStream: async (params) => {
+                if (params?.tools !== undefined && params.tools !== v3Tools) {
+                    logger.warn(`${providerNameForLoop}: middleware rewrote 'tools' on the streaming path; tool rewrites are not applied to the wire request yet — the original tool list was sent.`);
+                }
+                const transformedPrompt = Array.isArray(params?.prompt)
+                    ? params.prompt
+                    : promptMessages;
+                const conversation = messageBuilderToOpenAI(transformedPrompt, wireNameMaps?.toWire);
+                const sampled = {
+                    ...options,
+                    ...(typeof params?.maxOutputTokens === "number"
+                        ? { maxTokens: params.maxOutputTokens }
+                        : {}),
+                    ...(typeof params?.temperature === "number"
+                        ? { temperature: params.temperature }
+                        : {}),
+                    ...(typeof params?.topP === "number" ? { topP: params.topP } : {}),
+                };
+                loopPromise = this.runStreamLoop({
+                    maxSteps,
+                    modelId,
+                    url,
+                    fetchImpl,
+                    abortSignal,
+                    options: sampled,
+                    conversation,
+                    openAITools,
+                    openAIToolChoice,
+                    toolsRecord,
+                    toolNameFromWire: wireNameMaps?.fromWire,
+                    emitter,
+                    toolsUsed,
+                    toolExecutionSummaries,
+                    pushChunk: channel.push,
+                    closeChannel: channel.close,
+                    resolveUsage,
+                    resolveFinish,
+                });
+                const completion = loopPromise.then(() => Promise.all([usagePromise, finishPromise]).then(([usage, reason]) => ({
+                    type: "finish",
+                    finishReason: { unified: reason },
+                    usage: {
+                        inputTokens: {
+                            total: usage.promptTokens,
+                            cacheRead: usage.cacheReadTokens,
+                        },
+                        outputTokens: { total: usage.completionTokens },
+                    },
+                })));
+                // The producer can reject before the consumer pulls its terminal event.
+                void completion.catch(() => undefined);
+                return {
+                    stream: chunksToV3Stream(channel.iterable, completion, () => consumerAbortController.abort()),
+                };
+            },
+        };
+        // A middleware chain that blocks (guardrails' precall path) returns its own
+        // stream without calling `doStream`, so the loop may never start. Every
+        // later reader of `loopPromise` has to tolerate that.
+        let chunkSource;
+        try {
+            const wrappedStreamModel = await this.applyMiddlewareToModel(streamBaseModel, options);
+            if (typeof wrappedStreamModel === "string") {
+                throw new Error("Native stream model handle required");
+            }
+            const { stream } = await wrappedStreamModel.doStream(v3Params);
+            chunkSource = v3StreamToChunks(stream, (part) => {
+                if (!loopPromise) {
+                    const input = part.usage.inputTokens.total ?? 0;
+                    const output = part.usage.outputTokens.total ?? 0;
+                    resolveUsage({
+                        promptTokens: input,
+                        completionTokens: output,
+                        totalTokens: input + output,
+                    });
+                    resolveFinish(part.finishReason.unified);
+                }
+            });
+        }
+        catch (error) {
+            consumerAbortController.abort();
+            channel.close();
+            timeoutController?.cleanup();
+            throw error;
+        }
         // Closure-scoped capture: the runStreamLoop's catch block stashes the
         // underlying provider error here so we can pass it through to
         // buildNoOutputSentinel for richer telemetry (matches the pattern in
@@ -1025,7 +1204,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         const transformedStream = async function* () {
             let contentYielded = 0;
             try {
-                for await (const chunk of channel.iterable) {
+                for await (const chunk of chunkSource) {
                     if ("content" in chunk &&
                         typeof chunk.content === "string" &&
                         chunk.content.length > 0) {
@@ -1034,6 +1213,8 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     yield chunk;
                 }
                 // Surface any error that the loop threw after we drained the channel.
+                // `loopPromise` is undefined when a middleware blocked the request
+                // before `doStream` ran, in which case there is no loop to surface.
                 await loopPromise;
                 // No-output path: stream completed normally but yielded zero text.
                 // Build an enriched sentinel + stamp the active OTel span so
@@ -1062,6 +1243,15 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 throw streamError;
             }
             finally {
+                if (!loopPromise) {
+                    resolveUsage({
+                        promptTokens: 0,
+                        completionTokens: 0,
+                        totalTokens: 0,
+                    });
+                    resolveFinish("stop");
+                }
+                timeoutController?.cleanup();
                 if (!consumerAbortController.signal.aborted) {
                     consumerAbortController.abort();
                 }
@@ -1101,7 +1291,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             }))),
         });
         loopPromise
-            .finally(() => timeoutController?.cleanup())
+            ?.finally(() => timeoutController?.cleanup())
             .catch((error) => {
             captureProviderError(error);
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.12.5",
+  "version": "12.12.6",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -101,6 +101,7 @@
     "test:bedrock-inference-profile": "pnpm exec tsx test/continuous-test-suite-bedrock-inference-profile.ts",
     "test:loop-engine": "pnpm exec tsx test/continuous-test-suite-loop-engine.ts",
     "test:middleware": "pnpm exec tsx test/continuous-test-suite-middleware.ts",
+    "test:stream-middleware": "pnpm exec tsx test/continuous-test-suite-stream-middleware.ts",
     "test:observability": "pnpm exec tsx test/continuous-test-suite-observability.ts",
     "test:ppt": "pnpm exec tsx test/continuous-test-suite-ppt.ts",
     "test:vertex-loop-characterization": "tsx test/continuous-test-suite-vertex-loop-characterization.ts",