@juspay/neurolink 12.12.5 → 12.12.7

package/dist/cli/commands/proxy.js

@@ -26,7 +26,7 @@ import { ProxyRuntimeConfigStore } from "../../proxy/runtimeConfig.js";
 import { startProxyLogCleanupScheduler } from "../../proxy/logCleanupScheduler.js";
 import { anthropicAccountKeysEqual, createAccountAllowlist, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, normalizeAnthropicAccountKey, shouldLoadFallbackCredential, } from "../../proxy/accountSelection.js";
 import { resolveProxyStatusAccountIdentity } from "../../proxy/codexAccountUsage.js";
-import { beginProxyRequest, getProxyActivitySnapshot, takeProxyResponseObservers, trackProxyResponse, } from "../../proxy/proxyActivity.js";
+import { beginProxyRequest, getProxyActivitySnapshot, observeProxyFinalLog, takeProxyResponseObservers, trackProxyResponse, } from "../../proxy/proxyActivity.js";
 import { flushProxyLifecycleEvents, getProxyLifecycleLoggerSnapshot, hashProxyLifecycleSessionId, logProxyLifecycleEvent, } from "../../proxy/proxyLifecycle.js";
 import { describeInstallFailure, getGlobalInstallArgs, isTransientInstallFailure, resolveGlobalInstaller, validateInstalledVersion, } from "../../proxy/globalInstaller.js";
 import { startUpdaterWorkerSupervisor } from "../../proxy/updaterSupervisor.js";
@@ -1079,10 +1079,14 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
             rejectForUpdate: readiness.drainingForUpdate,
         };
         requestMetadata.set(c.req.raw, metadata);
+        const stopObservingFinalLog = observeProxyFinalLog(metadata.requestId, (entry) => {
+            metadata.terminalResult = entry;
+        });
         const finishActivity = metadata.rejectForUpdate
             ? () => undefined
             : beginProxyRequest();
         const finish = () => {
+            stopObservingFinalLog();
             finishActivity();
             // Borrowed traffic holds a concurrency slot for the lifetime of the
             // response body, so it is released here rather than when the handler
@@ -1130,15 +1134,9 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                     }
                 }
             };
-            const notifyRouteTerminal = (details) => {
-                for (const observer of routeResponseObservers) {
-                    try {
-                        observer.onTerminal?.(details);
-                    }
-                    catch {
-                        // Route-level accounting must never interfere with the relay.
-                    }
-                }
+            const notifyRouteTerminal = async (details) => {
+                const results = await withTimeout(Promise.allSettled(routeResponseObservers.map(async (observer) => observer.onTerminal?.(details))), 2_000, "Timed out joining proxy response accounting");
+                return results.some((result) => result.status === "rejected");
             };
             c.res = trackProxyResponse(c.res, finish, {
                 onFirstChunk: ({ observedBodyBytes, responseChunks }) => {
@@ -1162,13 +1160,39 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                         responseChunks,
                     });
                 },
-                onTerminal: ({ outcome, observedBodyBytes, responseChunks }) => {
-                    if (outcome === "completed" &&
-                        metadata.terminalErrorType === "stream_error") {
-                        outcome = "stream_error";
+                onTerminal: async ({ outcome, error, observedBodyBytes, responseChunks, }) => {
+                    const terminalMonotonicMs = performance.now();
+                    const terminalTimestampMs = Date.now();
+                    // Route accounting may await SSE parsing/cancellation. Join it before
+                    // publishing the semantic terminal record; transport EOF alone is not
+                    // evidence of a successful model response.
+                    let accountingTimedOut = false;
+                    let accountingFailed = false;
+                    try {
+                        accountingFailed = await notifyRouteTerminal({
+                            outcome,
+                            error,
+                            observedBodyBytes,
+                            responseChunks,
+                        });
+                    }
+                    catch {
+                        accountingTimedOut = true;
                     }
+                    const final = metadata.terminalResult;
+                    const terminalOutcome = final?.terminalOutcome ??
+                        (outcome === "stream_error" ||
+                            metadata.terminalErrorType === "stream_error"
+                            ? "stream_error"
+                            : outcome === "client_cancelled"
+                                ? "client_cancelled"
+                                : responseStatus >= 400
+                                    ? "handler_error"
+                                    : "unknown");
                     logProxyLifecycleEvent({
                         event: "request_terminal",
+                        timestampMs: terminalTimestampMs,
+                        monotonicMs: terminalMonotonicMs,
                         requestId: metadata.requestId,
                         method: metadata.method,
                         path: metadata.path,
@@ -1180,20 +1204,33 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                         responseStatus,
                         observedBodyBytes,
                         responseChunks,
-                        elapsedMs: performance.now() - startedMonotonicMs,
-                        terminalOutcome: outcome,
-                        errorType: metadata.terminalErrorType,
-                        errorCode: metadata.terminalErrorCode,
-                    });
-                    notifyRouteTerminal({
-                        outcome,
-                        observedBodyBytes,
-                        responseChunks,
+                        elapsedMs: terminalMonotonicMs - startedMonotonicMs,
+                        terminalOutcome,
+                        finalStatus: final?.responseStatus,
+                        transportOutcome: outcome,
+                        outcomeSource: final
+                            ? "final_request"
+                            : responseStatus >= 400
+                                ? "http_status"
+                                : terminalOutcome === "unknown"
+                                    ? "unknown"
+                                    : "transport_error",
+                        telemetryStatus: accountingTimedOut
+                            ? "timeout"
+                            : accountingFailed
+                                ? "observer_error"
+                                : final
+                                    ? "complete"
+                                    : "missing_final",
+                        errorType: final?.errorType ?? metadata.terminalErrorType,
+                        errorCode: final?.errorCode ?? metadata.terminalErrorCode,
                     });
+                    stopObservingFinalLog();
                 },
             });
         }
         catch (error) {
+            stopObservingFinalLog();
             // Keep metadata available to app.onError, which records the client-facing
             // failure with the same request ID before deleting the WeakMap entry.
             finishActivity();
@@ -1238,7 +1275,7 @@ export async function createProxyStartApp(params) {
     const { createOpenAIProxyRoutes } = await import("../../server/routes/openaiProxyRoutes.js");
     const { createCodexProxyRoutes } = await import("../../server/routes/codexProxyRoutes.js");
     const { createGeminiProxyRoutes } = await import("../../server/routes/geminiProxyRoutes.js");
-    const { logBodyCapture, logRequest } = await import("../../proxy/requestLogger.js");
+    const { logBodyCapture, logRequest, getRequestLoggerSnapshot } = await import("../../proxy/requestLogger.js");
     const { recordFinalError } = await import("../../proxy/usageStats.js");
     const { admitInboundShareRequest, isGrantRequiredByEnv } = await import("../../proxy/shareGate.js");
     const { runWithShareContext } = await import("../../proxy/shareContext.js");
@@ -1978,6 +2015,7 @@ export async function createProxyStartApp(params) {
             })(),
             observability: {
                 lifecycle: getProxyLifecycleLoggerSnapshot(),
+                requestLogs: getRequestLoggerSnapshot(),
             },
             autoUpdate: {
                 enabled: isProxyAutoUpdateEnabled(),

package/dist/cli/commands/proxyAnalyze.js

@@ -70,6 +70,7 @@ function printAnalysis(report) {
     for (const [label, summary] of [
         ["Response headers", report.latencyMs.headers],
         ["First chunk", report.latencyMs.firstChunk],
+        ["First useful output", report.latencyMs.firstUsefulOutput],
         ["Terminal", report.latencyMs.terminal],
         ["Final request log", report.latencyMs.finalRequest],
         ["Account attempt", report.latencyMs.attempt],
@@ -100,7 +101,9 @@ function printAnalysis(report) {
     if (!report.coverage.comparableRequestAttempts) {
         logger.always(chalk.yellow("    WARNING: request and attempt totals do not cover a comparable full window; do not reconcile them as one cohort"));
     }
-    logger.always(`    ${report.dataQuality.linesRead} lines scanned, ${report.dataQuality.malformedLines} malformed, ${report.dataQuality.unsupportedLifecycleLines} unsupported lifecycle, ${report.dataQuality.lifecycleSequenceGaps} sequence gaps, ${report.dataQuality.lifecycleSequenceDuplicates} duplicates`);
+    logger.always(`    ${report.dataQuality.linesRead} lines scanned, ${report.dataQuality.malformedLines} malformed, ${report.dataQuality.unsupportedLifecycleLines} unsupported lifecycle, ${report.dataQuality.lifecycleSequenceGaps} sequence gaps, ${report.dataQuality.lifecycleSequenceDuplicates} duplicates (${report.dataQuality.conflictingLifecycleDuplicates} conflicting)`);
+    logger.always(`    Outcome evidence: ${report.dataQuality.finalOutcomeConflicts} conflicts reconciled, ${report.dataQuality.acceptedWithoutFinal} accepted without a final record, ${report.dataQuality.terminalWithoutFinal} transport terminals without a final record`);
+    logger.always(`    Repeated attempt records merged: ${report.dataQuality.duplicateAttempts}`);
     logger.always(`    Routing decisions: ${report.dataQuality.routingDecisions.valid} valid, ${report.dataQuality.routingDecisions.invalid} invalid, ${report.dataQuality.routingDecisions.absent} absent`);
     for (const [stream, range] of Object.entries(report.dataQuality.streams)) {
         if (range.observedFrom) {

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