@juspay/neurolink 12.12.6 → 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/proxy/codexUsage.d.ts

@@ -39,7 +39,7 @@
  * `prompt_tokens`/`completion_tokens` spellings. A `null` result means "not
  * observed", never "zero tokens".
  */
-import type { CodexStreamUsage } from "../types/index.js";
+import type { CodexStreamUsage, CodexStreamEvidence } from "../types/index.js";
 /**
  * Pull usage out of one parsed SSE `data:` payload.
  *
@@ -65,4 +65,5 @@ export declare function scanCodexSSEForUsage(text: string): CodexStreamUsage | n
 export declare function createCodexUsageTap(): {
     stream: TransformStream<Uint8Array, Uint8Array>;
     usage: Promise<CodexStreamUsage | null>;
+    evidence: () => CodexStreamEvidence;
 };

package/dist/proxy/codexUsage.js

@@ -40,6 +40,8 @@
  * observed", never "zero tokens".
  */
 import { appendFileSync } from "node:fs";
+import { extractSSEEvents } from "./sseInterceptor.js";
+import { sanitizeForLog } from "../utils/logSanitize.js";
 const nonNegativeInt = (value) => typeof value === "number" && Number.isFinite(value) && value > 0
     ? Math.floor(value)
     : 0;
@@ -161,6 +163,68 @@ function createCaptureSink() {
  * none was. It never rejects.
  */
 export function createCodexUsageTap() {
+    const evidence = { completed: false, terminalBytes: 0 };
+    let totalBytes = 0;
+    const inspectEvidence = (events) => {
+        for (const frame of events) {
+            try {
+                const event = JSON.parse(frame.data);
+                if (!event || typeof event !== "object") {
+                    continue;
+                }
+                const seen = extractCodexUsage(event);
+                if (seen) {
+                    latest = seen;
+                }
+                const type = event.type ?? frame.event;
+                if ((type === "response.output_text.delta" ||
+                    type === "response.function_call_arguments.delta") &&
+                    typeof event.delta === "string" &&
+                    event.delta.length > 0) {
+                    evidence.firstUsefulOutputAt ??= Date.now();
+                }
+                if (type === "response.completed") {
+                    evidence.completed = true;
+                    evidence.terminalBytes = totalBytes;
+                }
+                else if (type === "error" ||
+                    type === "response.failed" ||
+                    type === "response.incomplete") {
+                    evidence.errorType = "stream_error";
+                    const response = event.response;
+                    const details = response && typeof response === "object"
+                        ? response
+                        : event;
+                    const rawError = details.error;
+                    const error = rawError && typeof rawError === "object"
+                        ? rawError
+                        : details;
+                    const incomplete = details.incomplete_details;
+                    const reason = incomplete &&
+                        typeof incomplete === "object" &&
+                        "reason" in incomplete
+                        ? incomplete.reason
+                        : undefined;
+                    evidence.errorCode =
+                        typeof error.code === "string"
+                            ? sanitizeForLog(error.code).slice(0, 200)
+                            : typeof reason === "string"
+                                ? sanitizeForLog(reason).slice(0, 200)
+                                : String(type);
+                    evidence.errorMessage =
+                        typeof error.message === "string"
+                            ? sanitizeForLog(error.message).slice(0, 200)
+                            : type === "response.incomplete"
+                                ? "Codex reported an incomplete response"
+                                : "Codex reported a stream failure";
+                    evidence.terminalBytes = totalBytes;
+                }
+            }
+            catch {
+                // Unknown frames cannot establish successful completion.
+            }
+        }
+    };
     let settleUsage = () => { };
     const usage = new Promise((resolve) => {
         settleUsage = resolve;
@@ -179,40 +243,33 @@ export function createCodexUsageTap() {
     const capture = createCaptureSink();
     let carry = "";
     let latest = null;
-    /**
-     * Ceiling on the unterminated tail we are willing to hold.
-     *
-     * `carry` normally holds a fraction of one SSE line, because every newline
-     * flushes it. A stream that never sends one — a hung upstream, a
-     * non-SSE body relayed by mistake — would otherwise grow it without bound
-     * for the life of the request. One `response.completed` event is a few
-     * hundred bytes, so a megabyte is far past any real event, and dropping the
-     * tail costs at most the usage reading this tap is allowed to miss anyway.
-     */
+    // Bound malformed unterminated events without ever withholding relay bytes.
     const CARRY_LIMIT_CHARS = 1024 * 1024;
+    let discardingEvent = false;
     const transformer = {
         transform(chunk, controller) {
             // Bytes go out first and unconditionally: nothing below can delay or
             // alter what the client receives.
             controller.enqueue(chunk);
+            totalBytes += chunk.byteLength;
             try {
                 capture?.(chunk);
                 carry += decoder.decode(chunk, { stream: true });
-                // Keep only the trailing partial line; events are newline-delimited.
-                const lastBreak = carry.lastIndexOf("\n");
-                if (lastBreak === -1) {
-                    if (carry.length > CARRY_LIMIT_CHARS) {
-                        // No line break in a megabyte: this is not the SSE stream we can
-                        // read. Give up on the tail rather than grow forever.
-                        carry = "";
+                if (discardingEvent) {
+                    const boundary = /\r\n\r\n|\n\n|\r\r/.exec(carry);
+                    if (!boundary) {
+                        carry = carry.slice(-3);
+                        return;
                     }
-                    return;
+                    carry = carry.slice(boundary.index + boundary[0].length);
+                    discardingEvent = false;
                 }
-                const complete = carry.slice(0, lastBreak);
-                carry = carry.slice(lastBreak + 1);
-                const seen = scanCodexSSEForUsage(complete);
-                if (seen) {
-                    latest = seen;
+                const { events, remainder } = extractSSEEvents(carry);
+                carry = remainder;
+                inspectEvidence(events);
+                if (carry.length > CARRY_LIMIT_CHARS) {
+                    carry = carry.slice(-2);
+                    discardingEvent = true;
                 }
             }
             catch {
@@ -220,15 +277,7 @@ export function createCodexUsageTap() {
             }
         },
         flush() {
-            try {
-                const seen = scanCodexSSEForUsage(carry);
-                if (seen) {
-                    latest = seen;
-                }
-            }
-            catch {
-                // ignored — see above
-            }
+            // An event without its dispatch delimiter is incomplete on the wire.
             settle(latest);
         },
         /**
@@ -242,5 +291,5 @@ export function createCodexUsageTap() {
         },
     };
     const stream = new TransformStream(transformer);
-    return { stream, usage };
+    return { stream, usage, evidence: () => ({ ...evidence }) };
 }

package/dist/proxy/proxyActivity.d.ts

@@ -1,4 +1,7 @@
-import type { ProxyActivitySnapshot, ProxyResponseTrackingObserver } from "../types/index.js";
+import type { ProxyActivitySnapshot, ProxyResponseTrackingObserver, RequestLogEntry } from "../types/index.js";
+/** Join route accounting to the HTTP lifecycle without relying on write order. */
+export declare function observeProxyFinalLog(requestId: string, observer: (entry: RequestLogEntry) => void): () => void;
+export declare function notifyProxyFinalLog(entry: RequestLogEntry): void;
 export declare function registerProxyResponseObserver(metadata: object, observer: ProxyResponseTrackingObserver): void;
 export declare function takeProxyResponseObservers(metadata: object): ProxyResponseTrackingObserver[];
 /** Track one client-facing proxy request until its response body settles. */

package/dist/proxy/proxyActivity.js

@@ -8,6 +8,19 @@ let lastActivityAtMs = null;
 // response through one tracker, which fans these observers out at the point
 // where bytes actually leave the proxy.
 const responseObserversByMetadata = new WeakMap();
+const finalLogObservers = new Map();
+/** Join route accounting to the HTTP lifecycle without relying on write order. */
+export function observeProxyFinalLog(requestId, observer) {
+    finalLogObservers.set(requestId, observer);
+    return () => {
+        if (finalLogObservers.get(requestId) === observer) {
+            finalLogObservers.delete(requestId);
+        }
+    };
+}
+export function notifyProxyFinalLog(entry) {
+    finalLogObservers.get(entry.requestId)?.(entry);
+}
 export function registerProxyResponseObserver(metadata, observer) {
     const existing = responseObserversByMetadata.get(metadata);
     if (existing) {
@@ -69,12 +82,17 @@ export function isProxyActivityQuiet(snapshot, quietThresholdMs, nowMs = Date.no
 /** Keep activity open until the response body completes, errors, or is cancelled. */
 export function trackProxyResponse(response, finishRequest, observer) {
     if (!response.body) {
-        finishRequest();
-        safelyNotifyObserver(() => observer?.onTerminal?.({
-            outcome: "bodyless",
-            observedBodyBytes: 0,
-            responseChunks: 0,
-        }));
+        try {
+            const notified = observer?.onTerminal?.({
+                outcome: "bodyless",
+                observedBodyBytes: 0,
+                responseChunks: 0,
+            });
+            void Promise.resolve(notified).then(finishRequest, finishRequest);
+        }
+        catch {
+            finishRequest();
+        }
         return response;
     }
     const reader = response.body.getReader();
@@ -88,17 +106,25 @@ export function trackProxyResponse(response, finishRequest, observer) {
     void reader.closed.then(() => {
         sourceClosed = true;
     }, () => undefined);
-    const settle = (outcome) => {
+    const settle = (outcome, error) => {
         if (settled) {
             return;
         }
         settled = true;
-        finishRequest();
-        safelyNotifyObserver(() => observer?.onTerminal?.({
-            outcome,
-            observedBodyBytes,
-            responseChunks,
-        }));
+        // Keep drain accounting open through bounded terminal bookkeeping, but
+        // never hold back the client's response body while telemetry is written.
+        try {
+            const notified = observer?.onTerminal?.({
+                outcome,
+                error,
+                observedBodyBytes,
+                responseChunks,
+            });
+            void Promise.resolve(notified).then(finishRequest, finishRequest);
+        }
+        catch {
+            finishRequest();
+        }
     };
     const trackedBody = new ReadableStream({
         async pull(controller) {
@@ -120,7 +146,7 @@ export function trackProxyResponse(response, finishRequest, observer) {
                 }
             }
             catch (error) {
-                settle("stream_error");
+                settle("stream_error", error);
                 controller.error(error);
             }
         },