@juspay/neurolink 12.12.4 → 12.12.6

package/dist/cli/commands/proxy.js

@@ -66,7 +66,6 @@ const gatedShareRequests = new WeakSet();
 const PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS = 5_000;
 /** How long shutdown waits on the share listener before moving on. */
 const SHARE_LISTENER_CLOSE_TIMEOUT_MS = 10_000;
-const PROXY_STATUS_TOKEN_READ_TIMEOUT_MS = 2_000;
 const PROXY_STATUS_RECONCILE_TIMEOUT_MS = 750;
 const PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS = 750;
 // Allowed drift between a pid's OS-reported start time and the persisted
@@ -1164,6 +1163,10 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                     });
                 },
                 onTerminal: ({ outcome, observedBodyBytes, responseChunks }) => {
+                    if (outcome === "completed" &&
+                        metadata.terminalErrorType === "stream_error") {
+                        outcome = "stream_error";
+                    }
                     logProxyLifecycleEvent({
                         event: "request_terminal",
                         requestId: metadata.requestId,
@@ -1500,6 +1503,7 @@ export async function createProxyStartApp(params) {
                     shareOutcome.release();
                 }
             }
+            const requestAbortController = new AbortController();
             const ctx = {
                 requestId: metadata?.requestId ?? crypto.randomUUID(),
                 method: c.req.method,
@@ -1509,6 +1513,10 @@ export async function createProxyStartApp(params) {
                 params: c.req.param(),
                 body,
                 rawBody,
+                abortSignal: AbortSignal.any([
+                    c.req.raw.signal,
+                    requestAbortController.signal,
+                ]),
                 // The proxy runtime exposes only the structural slice of NeuroLink the
                 // routes use; narrow (overlap-checked) to the full class for ServerContext.
                 neurolink: params.neurolink,
@@ -1555,39 +1563,42 @@ export async function createProxyStartApp(params) {
                 Symbol.asyncIterator in Object(result)) {
                 const iterator = result[Symbol.asyncIterator]();
                 let cancelled = false;
+                const encoder = new TextEncoder();
                 const responseStream = new ReadableStream({
-                    async start(controller) {
+                    async pull(controller) {
+                        if (cancelled) {
+                            return;
+                        }
                         try {
-                            while (!cancelled) {
-                                const { value, done } = await iterator.next();
-                                if (done) {
-                                    break;
-                                }
-                                controller.enqueue(new TextEncoder().encode(value));
+                            const next = await iterator.next();
+                            if (cancelled) {
+                                return;
+                            }
+                            if (next.done) {
+                                controller.close();
+                            }
+                            else {
+                                controller.enqueue(encoder.encode(next.value));
                             }
-                            controller.close();
                         }
                         catch (streamErr) {
                             if (cancelled) {
-                                controller.close();
                                 return;
                             }
-                            const errMsg = streamErr instanceof Error
-                                ? streamErr.message
-                                : String(streamErr);
-                            const errorEvent = `event: error\ndata: ${JSON.stringify({ type: "error", error: { type: "api_error", message: `Stream interrupted: ${errMsg}` } })}\n\n`;
-                            try {
-                                controller.enqueue(new TextEncoder().encode(errorEvent));
-                            }
-                            catch {
-                                // Controller already errored — ignore
+                            if (metadata) {
+                                metadata.terminalErrorType = "stream_error";
                             }
+                            logger.debug("[proxy] response stream interrupted", {
+                                error: streamErr,
+                            });
+                            controller.enqueue(encoder.encode(`event: error\ndata: ${JSON.stringify({ type: "error", error: { type: "api_error", message: "Stream interrupted" } })}\n\n`));
                             controller.close();
                         }
                     },
-                    async cancel() {
+                    async cancel(reason) {
                         cancelled = true;
-                        await iterator.return?.();
+                        requestAbortController.abort(reason);
+                        await withTimeout(Promise.resolve(iterator.return?.()), 1000, "[proxy] response cancellation timed out").catch(() => undefined);
                     },
                 });
                 return new Response(responseStream, {
@@ -1697,48 +1708,24 @@ export async function createProxyStartApp(params) {
         let accountInventoryLoaded = false;
         try {
             const { tokenStore } = await import("../../auth/tokenStore.js");
-            const [anthropicKeys, codexKeys] = await withTimeout(Promise.all([
-                tokenStore.listByPrefix("anthropic:"),
-                tokenStore.listByPrefix("codex:"),
-            ]), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status account enumeration timed out");
-            for (const key of anthropicKeys) {
-                storedAnthropicAccountKeys.add(normalizeAnthropicAccountKey(key));
-            }
-            for (const key of codexKeys) {
-                storedCodexAccountKeys.add(key);
-            }
-            // Once account names are known, preserve them even when optional token
-            // metadata is slow. That keeps the status table useful and avoids
-            // incorrectly presenting known accounts as removed.
-            accountInventoryLoaded = true;
-            const storedKeys = [...anthropicKeys, ...codexKeys];
-            const inventory = await withTimeout((async () => {
-                const tokenExpirations = await Promise.all(storedKeys.map(async (key) => {
-                    try {
-                        const tokens = await withTimeout(tokenStore.peekTokens(key), PROXY_STATUS_TOKEN_READ_TIMEOUT_MS, "[proxy] /status token inspection timed out");
-                        return tokens ? [key, tokens.expiresAt] : undefined;
-                    }
-                    catch (error) {
-                        logger.debug(`[proxy] /status: failed to inspect token metadata for ${normalizeAnthropicAccountKey(key)}: ${error instanceof Error ? error.message : String(error)}`);
-                        return undefined;
-                    }
-                }));
-                const disabledKeys = await tokenStore.listDisabled();
-                return { tokenExpirations, disabledKeys };
-            })(), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status account metadata timed out");
-            for (const expiration of inventory.tokenExpirations) {
-                if (expiration) {
-                    const key = expiration[0].startsWith("anthropic:")
-                        ? normalizeAnthropicAccountKey(expiration[0])
-                        : expiration[0];
-                    storedAccountExpirations.set(key, expiration[1]);
+            const inventory = await withTimeout(tokenStore.getProviderSnapshot(), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status account inspection timed out");
+            for (const [storedKey, entry] of Object.entries(inventory)) {
+                if (!storedKey.startsWith("anthropic:") &&
+                    !storedKey.startsWith("codex:")) {
+                    continue;
+                }
+                const key = storedKey.startsWith("anthropic:")
+                    ? normalizeAnthropicAccountKey(storedKey)
+                    : storedKey;
+                (key.startsWith("anthropic:")
+                    ? storedAnthropicAccountKeys
+                    : storedCodexAccountKeys).add(key);
+                storedAccountExpirations.set(key, entry.tokens.expiresAt);
+                if (entry.disabled) {
+                    disabledProviderAccountKeys.add(key);
                 }
             }
-            for (const key of inventory.disabledKeys) {
-                disabledProviderAccountKeys.add(key.startsWith("anthropic:")
-                    ? normalizeAnthropicAccountKey(key)
-                    : key);
-            }
+            accountInventoryLoaded = true;
         }
         catch (err) {
             logger.debug(`[proxy] /status: failed to resolve account cooldown labels: ${err instanceof Error ? err.message : String(err)}`);
@@ -3090,7 +3077,15 @@ function printStatusStats(stats) {
             }
         }
     }
-    if (stats.accounts?.length) {
+    const historical = (stats.accounts ?? []).filter((account) => account.status === "unattributed");
+    const accounts = (stats.accounts ?? []).filter((account) => account.status !== "unattributed");
+    if (historical.length > 0) {
+        const sum = (field) => historical.reduce((total, account) => total + (account[field] ?? 0), 0);
+        console.info(`\n  Historical usage (provider unknown; included in totals):`);
+        console.info(`    ${historical.length} legacy records: ${sum("attempts")} attempts, ${sum("success")} success, ${sum("errors")} errors, ${sum("rateLimits")} rate-limited attempts`);
+        console.info("    Per-record history remains available with --format json.");
+    }
+    if (accounts.length > 0) {
         console.info(`\n  Accounts:`);
         const headers = [
             "ACCOUNT",
@@ -3101,8 +3096,8 @@ function printStatusStats(stats) {
             "RL",
             "STATUS",
         ];
-        const rows = stats.accounts.map((account) => [
-            account.label,
+        const rows = accounts.map((account) => [
+            account.key ?? account.label,
             account.type,
             String(account.attempts ?? account.requests ?? 0),
             String(account.success ?? 0),
@@ -3267,7 +3262,7 @@ export const proxyStatusCommand = {
                     });
                     if (statusResp.ok) {
                         const statusData = (await statusResp.json());
-                        liveStats = statusData.stats;
+                        liveStats = statusData.stats ?? null;
                         liveConfig = statusData.config;
                         status.workerVersion =
                             typeof statusData.version === "string"
@@ -3342,6 +3337,9 @@ export const proxyStatusCommand = {
                 else if (status.rolling?.draining.length) {
                     logger.always(`  ${chalk.bold("Handoff:")}    ${chalk.cyan(`${status.rolling.draining.length} previous worker(s) draining`)}`);
                 }
+                if (status.rolling) {
+                    logger.always(`  ${chalk.bold("Socket handoff:")} ${status.rolling.pendingTransfers ?? "unknown"} pending, ${status.rolling.queuedSockets} queued; ${status.rolling.rejectedSockets} rejected, ${status.rolling.failedTransfers} failed transfers since supervisor start`);
+                }
                 if (status.deferredUpdate) {
                     const active = status.deferredUpdate.activeRequests === null
                         ? "unknown activity"
@@ -3398,21 +3396,8 @@ export const proxyStatusCommand = {
                     logger.always("");
                     logger.always(chalk.gray("  (Could not reach proxy for live status)"));
                 }
-                // Try to get detailed stats
-                try {
-                    const liveUrl = status.url;
-                    const statusResp = await fetch(`${liveUrl}/status`, {
-                        signal: AbortSignal.timeout(2_000),
-                    });
-                    if (statusResp.ok) {
-                        const statusData = (await statusResp.json());
-                        if (statusData.stats) {
-                            printStatusStats(statusData.stats);
-                        }
-                    }
-                }
-                catch {
-                    /* non-fatal */
+                if (liveStats) {
+                    printStatusStats(liveStats);
                 }
             }
             else {

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