@juspay/neurolink 12.14.7 → 12.14.9

package/dist/server/routes/codexProxyRoutes.js

@@ -25,7 +25,10 @@ import { createCodexUsageTap } from "../../proxy/codexUsage.js";
 import { CODEX_ACCOUNT_PREFIX, parseCodexRateLimitHeaders, } from "../../proxy/codexAccountUsage.js";
 import { buildClientAttribution } from "../../proxy/clientAttribution.js";
 import { registerProxyResponseObserver } from "../../proxy/proxyActivity.js";
-import { logRequest, logRequestAttempt } from "../../proxy/requestLogger.js";
+import { logRequest, logRequestAttempt, logBodyCapture, isProxyBodyCaptureEnabled, } from "../../proxy/requestLogger.js";
+import { createRawStreamCapture } from "../../proxy/rawStreamCapture.js";
+import { resolveProxyLogTraceContext } from "../../proxy/proxyTraceContext.js";
+import { isBorrowedRequest } from "../../proxy/shareContext.js";
 import { ProxyTracer } from "../../proxy/proxyTracer.js";
 import { parseRetryAfterMs } from "../../proxy/routingPolicy.js";
 import { recordAttempt, recordAttemptError, recordFinalError, recordFinalSuccess, } from "../../proxy/usageStats.js";
@@ -272,6 +275,68 @@ function publishCodexHeaders(ctx, account, attempt, quota) {
 }
 /** Core pooled handler for POST /backend-api/codex/responses. */
 export async function handleCodexResponsesRequest(ctx) {
+    if (ctx.metadata?.[CODEX_FALLBACK_METADATA_KEY] !== true) {
+        void logBodyCapture({
+            timestamp: new Date().toISOString(),
+            requestId: ctx.requestId,
+            phase: "client_request",
+            model: codexCaptureModel(ctx),
+            stream: true,
+            headers: ctx.headers,
+            body: ctx.body,
+            contentType: "application/json",
+            ...resolveProxyLogTraceContext({ requestId: ctx.requestId }),
+        });
+    }
+    const response = await executeCodexResponsesRequest(ctx);
+    return ctx.metadata?.[CODEX_FALLBACK_METADATA_KEY] === true
+        ? response
+        : captureCodexResponse(ctx, response, "client_response");
+}
+function codexCaptureModel(ctx) {
+    const body = ctx.body;
+    return typeof body?.model === "string" ? body.model : "-";
+}
+/** Observe bytes through the existing bounded pass-through; cancellation still reaches upstream. */
+function captureCodexResponse(ctx, response, phase, account, attempt) {
+    if (!isProxyBodyCaptureEnabled()) {
+        return response;
+    }
+    const metadata = {
+        timestamp: new Date().toISOString(),
+        requestId: ctx.requestId,
+        phase,
+        model: codexCaptureModel(ctx),
+        stream: true,
+        headers: Object.fromEntries(response.headers.entries()),
+        contentType: response.headers.get("content-type") ?? undefined,
+        responseStatus: response.status,
+        account: account?.label,
+        accountType: account ? CODEX_ACCOUNT_TYPE : undefined,
+        attempt,
+        ...resolveProxyLogTraceContext({ requestId: ctx.requestId }),
+    };
+    if (!response.body || isBorrowedRequest()) {
+        void logBodyCapture(metadata);
+        return response;
+    }
+    const observed = createRawStreamCapture();
+    void observed.capture
+        .then((capture) => logBodyCapture({
+        ...metadata,
+        timestamp: new Date().toISOString(),
+        body: capture.text,
+        bodySize: capture.totalBytes,
+        sourceTruncated: capture.truncated,
+    }))
+        .catch(() => undefined);
+    return new Response(response.body.pipeThrough(observed.stream), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+async function executeCodexResponsesRequest(ctx) {
     const requestStartTime = Date.now();
     const body = ctx.body ?? {};
     const bodyStr = JSON.stringify(body);
@@ -475,9 +540,24 @@ export async function handleCodexResponsesRequest(ctx) {
                 recordAttempt(account.label, CODEX_ACCOUNT_TYPE);
                 let upstream;
                 try {
+                    const upstreamHeaders = buildCodexUpstreamHeaders(ctx.headers, account);
+                    void logBodyCapture({
+                        timestamp: new Date().toISOString(),
+                        requestId: ctx.requestId,
+                        phase: "upstream_request",
+                        model,
+                        stream: true,
+                        body: bodyStr,
+                        headers: upstreamHeaders,
+                        contentType: "application/json",
+                        account: account.label,
+                        accountType: CODEX_ACCOUNT_TYPE,
+                        attempt,
+                        ...tracer?.getTraceContext(),
+                    });
                     upstream = await fetch(CODEX_RESPONSES_URL, {
                         method: "POST",
-                        headers: buildCodexUpstreamHeaders(ctx.headers, account),
+                        headers: upstreamHeaders,
                         body: bodyStr,
                         signal: ctx.abortSignal
                             ? AbortSignal.any([
@@ -541,6 +621,7 @@ export async function handleCodexResponsesRequest(ctx) {
                     lastErrorStatus = 502;
                     break; // rotate to next account
                 }
+                upstream = captureCodexResponse(ctx, upstream, "upstream_response", account, attempt);
                 if (upstream.ok) {
                     const quota = parseCodexRateLimitHeaders(upstream.headers);
                     if (quota) {

package/dist/types/proxy.d.ts

@@ -561,6 +561,8 @@ export type RequestLogEntry = {
     firstUsefulOutputStatus?: "observed" | "no_useful_output" | "not_observed";
     /** Native protocol event that established the first useful output. */
     firstUsefulOutputEvent?: string;
+    /** Why first-output timing could not be established for this response. */
+    firstUsefulOutputUnavailableReason?: string;
     /** Requested reasoning effort retained independently of body capture. */
     reasoningEffort?: string;
     /** Small routing evidence retained even when response bodies are pruned. */
@@ -645,6 +647,8 @@ export type ProcessedProxyBodyCapture = {
 export type ProxyBodyCaptureAdmission = {
     limitingResource: "entry" | "captures" | "bytes" | "worker";
     estimatedBytes?: number;
+    /** Per-entry clone ceiling, independent of the aggregate queue ceiling. */
+    maxEntryBytes?: number;
     pending: number;
     pendingBytes: number;
     maxPending: number;
@@ -739,6 +743,7 @@ export type ProxyTelemetryCheck = {
 };
 /** Small stored metadata used by the doctor; bodies are queried separately. */
 export type ProxyTelemetryStoredRecord = Partial<RequestLogEntry> & {
+    recordedAtMicroseconds?: number;
     captureId?: string;
     bodySha256?: string;
     redactedBodyBytes?: number;
@@ -837,6 +842,8 @@ export type CodexTokenRefresher = (refreshToken: string) => Promise<{
 }>;
 export type ProxyBodyCaptureInput = {
     phase: string;
+    /** The stream observer retained only a bounded prefix. */
+    sourceTruncated?: boolean;
     headers?: Record<string, string>;
     body?: unknown;
     bodySize?: number;
@@ -2165,6 +2172,8 @@ export type ProxyBodyCaptureEntry = {
     headers?: Record<string, string>;
     body?: unknown;
     bodySize?: number;
+    /** The bounded stream observer omitted a suffix before redaction/processing. */
+    sourceTruncated?: boolean;
     contentType?: string;
     responseStatus?: number;
     durationMs?: number;
@@ -2335,6 +2344,8 @@ export type SSEContentBlock = {
 export type SSETelemetry = {
     messageStopReceived: boolean;
     firstUsefulOutputAt?: number;
+    firstUsefulOutputEvent?: string;
+    observationIncomplete?: boolean;
     messageId: string;
     model: string;
     usage: {
@@ -2358,6 +2369,7 @@ export type SSETelemetry = {
     /** Error carried as a terminal SSE `event: error`, if one was observed. */
     streamErrorMessage?: string;
     rawText?: string;
+    rawTextTruncated?: boolean;
 };
 /** Terminal outcome of a response body after the HTTP headers were sent. */
 export type StreamTerminalOutcome = {
@@ -2379,6 +2391,8 @@ export type StreamTerminalOutcomeTracker = {
 export type TelemetryAccumulator = {
     messageStopReceived: boolean;
     firstUsefulOutputAt?: number;
+    firstUsefulOutputEvent?: string;
+    observationIncomplete?: boolean;
     messageId: string;
     model: string;
     inputTokens: number;

package/dist/types/proxyRestart.d.ts

@@ -44,6 +44,31 @@ export type ProxyRestartControlOptions = {
     getInstalledVersion: () => Promise<string | undefined>;
     isUpdatePending: () => boolean;
     getStatus: () => Promise<unknown>;
+    /** Current supervisor process evidence; never infer it from a worker/plist. */
+    getTelemetry?: () => ProxyProcessTelemetrySnapshot;
     /** Report control-server errors without stopping the serving listener. */
     log?: (message: string) => void;
 };
+/** Small read-only process evidence, excluding environment variables and log content. */
+export type ProxyProcessTelemetrySnapshot = {
+    pid: number;
+    checkedAt: string;
+    configuredSink: "otel" | "file";
+    lifecycleSink: string;
+    otelInitialized: boolean;
+    stdio: {
+        stdout: "file" | "non_file" | "unavailable";
+        stderr: "file" | "non_file" | "unavailable";
+    };
+    exportDropped: number;
+    exportUnconfirmed: number;
+};
+export type ProxySupervisorTelemetry = {
+    status: "available";
+    process: ProxyProcessTelemetrySnapshot;
+} | {
+    status: "unavailable";
+    reason: string;
+} | {
+    status: "not_applicable";
+};

package/dist/utils/logSanitize.js

@@ -47,7 +47,7 @@ const SECRET_PATTERN = new RegExp(
     // Bare tokens by known prefix (e.g. `sk-abc…`, `r8_xyz…`)
     `|\\b(?:${PREFIX_PATTERN})[_\\-][A-Za-z0-9_\\-\\.]{8,}\\b` +
     // Generic key=value pairs (URL params, JSON bodies, header dumps)
-    "|\\b(?:api[_-]?key|access[_-]?token|secret[_-]?key|refresh[_-]?token)\\s*[:=]\\s*['\"]?[^\\s,;'\"&]+", "gi");
+    "|\\b(?:api[_-]?key|access[_-]?token|secret[_-]?key|refresh[_-]?token)['\"]?\\s*[:=]\\s*['\"]?[^\\s,;'\"&]+", "gi");
 /** Header names that should always be redacted regardless of value shape. */
 const SENSITIVE_HEADER_NAMES = [
     "authorization",

package/dist/utils/timeout.d.ts

@@ -5,10 +5,21 @@
  * Supports multiple time formats: milliseconds, seconds, minutes, hours.
  */
 import type { TimeoutConfig, TimeoutResult } from "../types/index.js";
+import { TimeoutError as BaseTimeoutError } from "./async/withTimeout.js";
 /**
- * Custom error class for timeout operations
+ * Custom error class for timeout operations.
+ *
+ * Extends the base {@link BaseTimeoutError} (from `./async/withTimeout.js`)
+ * rather than `Error` directly, merging what were two independent internal
+ * `TimeoutError` classes onto one prototype chain — an `instanceof` check
+ * against either module's `TimeoutError` now recognizes errors thrown by
+ * this class. Constructor signature, `.name`, and the extra
+ * `timeout`/`provider`/`operation` fields are unchanged so all 15 existing
+ * `instanceof TimeoutError` call sites keep working exactly as before;
+ * `super(message, timeout)` additionally populates the base class's
+ * `timeoutMs` field (equal to `timeout`) as a byproduct.
  */
-export declare class TimeoutError extends Error {
+export declare class TimeoutError extends BaseTimeoutError {
     readonly timeout: number;
     readonly provider?: string | undefined;
     readonly operation?: "generate" | "stream" | undefined;

package/dist/utils/timeout.js

@@ -4,15 +4,26 @@
  * Provides flexible timeout parsing and error handling for AI operations.
  * Supports multiple time formats: milliseconds, seconds, minutes, hours.
  */
+import { TimeoutError as BaseTimeoutError } from "./async/withTimeout.js";
 /**
- * Custom error class for timeout operations
+ * Custom error class for timeout operations.
+ *
+ * Extends the base {@link BaseTimeoutError} (from `./async/withTimeout.js`)
+ * rather than `Error` directly, merging what were two independent internal
+ * `TimeoutError` classes onto one prototype chain — an `instanceof` check
+ * against either module's `TimeoutError` now recognizes errors thrown by
+ * this class. Constructor signature, `.name`, and the extra
+ * `timeout`/`provider`/`operation` fields are unchanged so all 15 existing
+ * `instanceof TimeoutError` call sites keep working exactly as before;
+ * `super(message, timeout)` additionally populates the base class's
+ * `timeoutMs` field (equal to `timeout`) as a byproduct.
  */
-export class TimeoutError extends Error {
+export class TimeoutError extends BaseTimeoutError {
     timeout;
     provider;
     operation;
     constructor(message, timeout, provider, operation) {
-        super(message);
+        super(message, timeout);
         this.timeout = timeout;
         this.provider = provider;
         this.operation = operation;