@juspay/neurolink 10.4.2 → 10.4.4

package/dist/lib/types/proxy.d.ts

@@ -671,6 +671,29 @@ export type AnthropicUpstreamFetchResult = {
     sawNetworkError: boolean;
     upstreamSpan?: Span;
 };
+export type ProxyTerminalErrorCategory = "authentication" | "client_cancelled" | "fallback_exhausted" | "invalid_request" | "proxy_error" | "rate_limit" | "stream_error" | "unclassified" | "upstream_error" | "other";
+/** Compact, redacted terminal failure retained independently of body logs. */
+export type ProxyTerminalErrorSummary = {
+    id: string;
+    at: number;
+    status: number;
+    category: ProxyTerminalErrorCategory;
+    requestId?: string;
+    account?: string;
+    accountType?: string;
+    errorType?: string;
+    errorCode?: string;
+    terminalOutcome?: string;
+    message?: string;
+};
+/** Optional terminal context supplied when a final request error is recorded. */
+export type ProxyTerminalErrorDetails = {
+    requestId?: string;
+    errorType?: string;
+    errorCode?: string;
+    terminalOutcome?: string;
+    message?: string;
+};
 export type AccountStats = {
     label: string;
     type: string;
@@ -700,6 +723,19 @@ export type ProxyStats = {
     totalQuotaRateLimits: number;
     accounts: Record<string, AccountStats>;
 };
+/** Bounded terminal-error state stored separately from counters and body logs. */
+export type ProxyTerminalErrorJournal = {
+    startedAt: number;
+    totalErrors: number;
+    counts: Record<ProxyTerminalErrorCategory, number>;
+    recent: ProxyTerminalErrorSummary[];
+};
+export type ProxyUsageStatsSnapshot = {
+    stats: ProxyStats;
+    statsVersion: number;
+    terminalErrors: ProxyTerminalErrorJournal;
+    terminalErrorsVersion: number;
+};
 /** Durability and reconciliation state for the proxy usage counters. */
 export type ProxyStatsPersistenceStatus = {
     enabled: boolean;
@@ -712,6 +748,14 @@ export type ProxyStatsPersistenceStatus = {
     lastReconciledAt: number | null;
     lastRecoveryAt: number | null;
     lastError: string | null;
+    terminalErrorsFilePath?: string | null;
+    terminalErrorsRevision?: number;
+    terminalErrorsPending?: number;
+    terminalErrorsInFlight?: number;
+    terminalErrorsUnpersisted?: number;
+    terminalErrorsLastFlushedAt?: number | null;
+    terminalErrorsLastRecoveryAt?: number | null;
+    terminalErrorsLastError?: string | null;
 };
 /** Versioned on-disk snapshot shared by overlapping proxy workers. */
 export type PersistedProxyStatsSnapshot = {
@@ -720,6 +764,13 @@ export type PersistedProxyStatsSnapshot = {
     updatedAt: number;
     stats: ProxyStats;
 };
+/** Versioned terminal-error snapshot isolated from rolling-worker counter writes. */
+export type PersistedProxyTerminalErrorSnapshot = {
+    schemaVersion: 1;
+    revision: number;
+    updatedAt: number;
+    journal: ProxyTerminalErrorJournal;
+};
 /** Ownership metadata for the proxy statistics cross-process lock. */
 export type ProxyStatsLockOwner = {
     token: string;
@@ -729,6 +780,7 @@ export type ProxyStatsLockOwner = {
 /** Construction options for an isolated proxy statistics store. */
 export type ProxyUsageStatsStoreOptions = {
     filePath?: string;
+    terminalErrorsFilePath?: string;
     flushIntervalMs?: number;
     lockTimeoutMs?: number;
     staleLockMs?: number;
@@ -1121,6 +1173,7 @@ export type ProxyAnalysisAccount = {
     unclassifiedRateLimits: number;
 };
 /** Offline report generated from proxy request, attempt, and lifecycle logs. */
+export type ProxyAnalysisStreamName = "lifecycle" | "requests" | "attempts" | "debug";
 export type ProxyAnalysisReport = {
     generatedAt: string;
     since: string;
@@ -1129,6 +1182,7 @@ export type ProxyAnalysisReport = {
         lifecycle: number;
         requests: number;
         attempts: number;
+        debug: number;
     };
     coverage: {
         lifecycle: boolean;
@@ -1143,6 +1197,20 @@ export type ProxyAnalysisReport = {
         unsupportedLifecycleLines: number;
         lifecycleSequenceGaps: number;
         lifecycleSequenceDuplicates: number;
+        streams: Record<ProxyAnalysisStreamName, {
+            observedFrom: string | null;
+            observedTo: string | null;
+            startsAtOrBeforeRequestedWindow: boolean;
+        }>;
+        bodyArtifacts: {
+            capturesIndexed: number;
+            artifactsReferenced: number;
+            artifactsPresent: number;
+            artifactsMissing: number;
+            invalidPaths: number;
+            writeFailures: number;
+            truncatedCaptures: number;
+        };
     };
     lifecycle: {
         accepted: number;
@@ -1392,6 +1460,7 @@ export type StoredBodyArtifact = {
     storedFileBytes?: number;
     redactedBody?: string;
     bodyTruncated?: boolean;
+    bodyWriteFailed?: boolean;
 };
 /** File the proxy logger tracks for rotation and cleanup. */
 export type ManagedLogFile = {
@@ -1653,6 +1722,11 @@ export type ProxyWorkerStatusMessage = {
     generation: number;
     pid: number;
     socketId: string;
+} | {
+    type: "proxy-worker:replacement-requested";
+    generation: number;
+    pid: number;
+    reason: "environment";
 };
 export type ProxyWorkerSocketMessage = {
     type: "proxy-worker:socket";
@@ -1661,6 +1735,8 @@ export type ProxyWorkerSocketMessage = {
 };
 export type ProxyWorkerIpcMessage = ProxyWorkerControlMessage | ProxyWorkerStatusMessage | ProxyWorkerSocketMessage;
 export type TransferableProxySocket = Pick<import("node:net").Socket, "destroy" | "end" | "pause" | "resume" | "once">;
+/** A transferred socket whose temporary handoff listeners can be detached. */
+export type DetachableTransferableProxySocket = TransferableProxySocket & Pick<import("node:net").Socket, "off">;
 export type RollingWorkerHandle = {
     pid: number;
     sendControl: (message: ProxyWorkerControlMessage) => void;
@@ -1714,6 +1790,11 @@ export type RollingWorkerSupervisorOptions = {
     socketQueueTimeoutMs?: number;
     shutdownTimeoutMs?: number;
     onStateChange?: (snapshot: RollingWorkerSupervisorSnapshot) => void;
+    onReplacementRequested?: (request: {
+        generation: number;
+        pid: number;
+        reason: "environment";
+    }) => void;
     log?: (message: string) => void;
 };
 export type RollingProxyServerOptions = {
@@ -1854,6 +1935,7 @@ export type ProxyRuntimeConfigReloadResult = {
     applied: boolean;
     changed: boolean;
     generation: number;
+    environmentChanged?: boolean;
     error?: string;
 };
 /** Safe runtime configuration diagnostics exposed through proxy status. */
@@ -1921,6 +2003,11 @@ export type StatusStats = {
     totalRateLimits: number;
     totalTransientRateLimits?: number;
     totalQuotaRateLimits?: number;
+    terminalErrors?: ProxyTerminalErrorJournal;
+    lastTerminalError?: ProxyTerminalErrorSummary | null;
+    terminalErrorDetailsComparable?: boolean;
+    terminalErrorDetailsMissing?: number;
+    terminalErrorDetailsExcess?: number;
     accounts?: {
         label: string;
         type: string;
@@ -1933,7 +2020,9 @@ export type StatusStats = {
         transientRateLimits?: number;
         quotaRateLimits?: number;
         cooling: boolean;
-        status?: "active" | "cooling" | "disabled" | "excluded" | "removed";
+        allowed?: boolean;
+        expired?: boolean;
+        status?: "active" | "cooling" | "disabled" | "expired" | "excluded" | "removed" | "internal" | "unattributed";
     }[];
     persistence?: ProxyStatsPersistenceStatus;
 };

package/dist/proxy/proxyAnalysis.js

@@ -1,17 +1,41 @@
 import { createReadStream } from "node:fs";
-import { readdir } from "node:fs/promises";
+import { lstat, readdir, realpath, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { createInterface } from "node:readline";
-import { join, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
 const LIFECYCLE_FILE_PATTERN = /^proxy-lifecycle-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const REQUEST_FILE_PATTERN = /^proxy-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const ATTEMPT_FILE_PATTERN = /^proxy-attempts-\d{4}-\d{2}-\d{2}\.jsonl$/;
+const DEBUG_FILE_PATTERN = /^proxy-debug-\d{4}-\d{2}-\d{2}\.jsonl$/;
+const ARTIFACT_STAT_CONCURRENCY = 64;
 const LIFECYCLE_EVENTS = new Set([
     "request_accepted",
     "response_headers",
     "response_first_chunk",
     "request_terminal",
 ]);
+function isContainedPath(root, candidate) {
+    const candidateRelative = relative(root, candidate);
+    return (candidateRelative.length > 0 &&
+        !isAbsolute(candidateRelative) &&
+        candidateRelative !== ".." &&
+        !candidateRelative.startsWith(`..${sep}`));
+}
+async function inspectBodyArtifact(artifactPath, canonicalBodiesRoot) {
+    if (!canonicalBodiesRoot) {
+        return "missing";
+    }
+    try {
+        const canonicalArtifactPath = await realpath(artifactPath);
+        if (!isContainedPath(canonicalBodiesRoot, canonicalArtifactPath)) {
+            return "invalid";
+        }
+        return (await stat(canonicalArtifactPath)).isFile() ? "present" : "missing";
+    }
+    catch {
+        return "missing";
+    }
+}
 function increment(counter, key) {
     counter[key] = (counter[key] ?? 0) + 1;
 }
@@ -192,6 +216,7 @@ async function discoverLogFiles(logsDir) {
         lifecycleFiles: matching(LIFECYCLE_FILE_PATTERN),
         requestFiles: matching(REQUEST_FILE_PATTERN),
         attemptFiles: matching(ATTEMPT_FILE_PATTERN),
+        debugFiles: matching(DEBUG_FILE_PATTERN),
     };
 }
 /** Analyze local proxy logs without reading request or response body artifacts. */
@@ -199,7 +224,24 @@ export async function analyzeProxyLogs(options) {
     const nowMs = options?.nowMs ?? Date.now();
     const sinceMs = parseSince(options?.since ?? "24h", nowMs);
     const logsDir = resolve(options?.logsDir ?? join(homedir(), ".neurolink", "logs"));
-    const { lifecycleFiles, requestFiles, attemptFiles } = await discoverLogFiles(logsDir);
+    const { lifecycleFiles, requestFiles, attemptFiles, debugFiles } = await discoverLogFiles(logsDir);
+    const observedRanges = {
+        lifecycle: { from: null, to: null },
+        requests: { from: null, to: null },
+        attempts: { from: null, to: null },
+        debug: { from: null, to: null },
+    };
+    const observeTimestamp = (stream, record) => {
+        const timestamp = Date.parse(String(record.timestamp ?? ""));
+        if (!Number.isFinite(timestamp)) {
+            return null;
+        }
+        const range = observedRanges[stream];
+        range.from =
+            range.from === null ? timestamp : Math.min(range.from, timestamp);
+        range.to = range.to === null ? timestamp : Math.max(range.to, timestamp);
+        return timestamp;
+    };
     let linesRead = 0;
     let malformedLines = 0;
     let unsupportedLifecycleLines = 0;
@@ -216,8 +258,8 @@ export async function analyzeProxyLogs(options) {
     const sequences = new Map();
     for (const filePath of lifecycleFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
-            const timestamp = Date.parse(String(record.timestamp ?? ""));
-            if (!Number.isFinite(timestamp) || timestamp < sinceMs) {
+            const timestamp = observeTimestamp("lifecycle", record);
+            if (timestamp === null || timestamp < sinceMs) {
                 return;
             }
             const event = stringValue(record.event);
@@ -298,8 +340,8 @@ export async function analyzeProxyLogs(options) {
     let unclassifiedRateLimits = 0;
     for (const filePath of attemptFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
-            const timestamp = Date.parse(String(record.timestamp ?? ""));
-            if (!Number.isFinite(timestamp) || timestamp < sinceMs) {
+            const timestamp = observeTimestamp("attempts", record);
+            if (timestamp === null || timestamp < sinceMs) {
                 return;
             }
             const requestId = stringValue(record.requestId);
@@ -360,8 +402,8 @@ export async function analyzeProxyLogs(options) {
     const terminalStreamErrors = new Set();
     for (const filePath of requestFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
-            const timestamp = Date.parse(String(record.timestamp ?? ""));
-            if (!Number.isFinite(timestamp) || timestamp < sinceMs) {
+            const timestamp = observeTimestamp("requests", record);
+            if (timestamp === null || timestamp < sinceMs) {
                 return;
             }
             const requestId = stringValue(record.requestId);
@@ -391,6 +433,70 @@ export async function analyzeProxyLogs(options) {
             malformedLines += 1;
         });
     }
+    let capturesIndexed = 0;
+    let truncatedCaptures = 0;
+    let writeFailures = 0;
+    let invalidPaths = 0;
+    const referencedArtifacts = new Set();
+    const bodiesRoot = resolve(logsDir, "bodies");
+    for (const filePath of debugFiles) {
+        linesRead += await readJsonLines(filePath, (record) => {
+            const timestamp = observeTimestamp("debug", record);
+            if (timestamp === null || timestamp < sinceMs) {
+                return;
+            }
+            if (record.type !== "body_capture") {
+                return;
+            }
+            capturesIndexed += 1;
+            truncatedCaptures += record.bodyTruncated === true ? 1 : 0;
+            writeFailures += record.bodyWriteFailed === true ? 1 : 0;
+            const bodyPath = stringValue(record.bodyPath);
+            if (!bodyPath) {
+                return;
+            }
+            if (bodyPath.includes("\0") || bodyPath.split(/[\\/]/).includes("..")) {
+                invalidPaths += 1;
+                return;
+            }
+            const resolvedBodyPath = resolve(logsDir, bodyPath);
+            if (!isContainedPath(bodiesRoot, resolvedBodyPath)) {
+                invalidPaths += 1;
+                return;
+            }
+            referencedArtifacts.add(resolvedBodyPath);
+        }, () => {
+            malformedLines += 1;
+        });
+    }
+    const artifactPaths = [...referencedArtifacts];
+    let canonicalBodiesRoot = null;
+    let bodiesRootUnsafe = false;
+    try {
+        const bodiesRootStat = await lstat(bodiesRoot);
+        if (bodiesRootStat.isDirectory() && !bodiesRootStat.isSymbolicLink()) {
+            canonicalBodiesRoot = await realpath(bodiesRoot);
+        }
+        else {
+            bodiesRootUnsafe = true;
+        }
+    }
+    catch {
+        // A missing body directory means every lexically valid reference is absent.
+    }
+    let artifactsPresent = 0;
+    let artifactsMissing = 0;
+    for (let offset = 0; offset < artifactPaths.length; offset += ARTIFACT_STAT_CONCURRENCY) {
+        const presence = await Promise.all(artifactPaths
+            .slice(offset, offset + ARTIFACT_STAT_CONCURRENCY)
+            .map((artifactPath) => bodiesRootUnsafe
+            ? Promise.resolve("invalid")
+            : inspectBodyArtifact(artifactPath, canonicalBodiesRoot)));
+        artifactsPresent += presence.filter((value) => value === "present").length;
+        artifactsMissing += presence.filter((value) => value === "missing").length;
+        invalidPaths += presence.filter((value) => value === "invalid").length;
+    }
+    const artifactsReferenced = artifactsPresent + artifactsMissing;
     const finalSummary = summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByRequest, accounts);
     return {
         generatedAt: new Date(nowMs).toISOString(),
@@ -400,11 +506,12 @@ export async function analyzeProxyLogs(options) {
             lifecycle: lifecycleFiles.length,
             requests: requestFiles.length,
             attempts: attemptFiles.length,
+            debug: debugFiles.length,
         },
         coverage: {
-            lifecycle: lifecycleFiles.length > 0,
-            finalRequests: requestFiles.length > 0,
-            attempts: attemptFiles.length > 0,
+            lifecycle: accepted.size + headers.size + firstChunks.size + terminal.size > 0,
+            finalRequests: finalRequests.size > 0 || terminalStreamErrors.size > 0,
+            attempts: totalAttempts > 0,
             attemptLatency: attemptLatency.length > 0,
             cacheUsage: finalSummary.cache.requestsWithUsage > 0,
         },
@@ -414,6 +521,23 @@ export async function analyzeProxyLogs(options) {
             unsupportedLifecycleLines,
             lifecycleSequenceGaps,
             lifecycleSequenceDuplicates,
+            streams: Object.fromEntries(Object.entries(observedRanges).map(([stream, range]) => [
+                stream,
+                {
+                    observedFrom: range.from === null ? null : new Date(range.from).toISOString(),
+                    observedTo: range.to === null ? null : new Date(range.to).toISOString(),
+                    startsAtOrBeforeRequestedWindow: range.from !== null && range.from <= sinceMs,
+                },
+            ])),
+            bodyArtifacts: {
+                capturesIndexed,
+                artifactsReferenced,
+                artifactsPresent,
+                artifactsMissing,
+                invalidPaths,
+                writeFailures,
+                truncatedCaptures,
+            },
         },
         lifecycle: {
             accepted: accepted.size,

package/dist/proxy/proxyTranslationEngine.d.ts

@@ -77,6 +77,7 @@ export declare function handleTranslatedJsonRequest(args: {
     attempts: ProxyTranslationAttempt[];
     tracer?: ProxyTracer;
     requestStartTime: number;
+    terminalFailureStatus?: number;
 }): Promise<unknown>;
 /**
  * Build the /v1/models response in OpenAI list format.

package/dist/proxy/proxyTranslationEngine.js

@@ -247,6 +247,7 @@ export async function handleTranslatedStreamRequest(args) {
     let keepAliveTimer;
     let cancelled = false;
     let succeeded = false;
+    let streamInterruptedAfterOutput = false;
     let translatedModel;
     let finalStreamError = "No translation providers succeeded";
     let upstreamIterator;
@@ -267,6 +268,9 @@ export async function handleTranslatedStreamRequest(args) {
             }, KEEPALIVE_INTERVAL_MS);
             try {
                 for (let attemptIndex = 0; attemptIndex < attempts.length; attemptIndex++) {
+                    if (cancelled) {
+                        break;
+                    }
                     const attempt = attempts[attemptIndex];
                     lastAttemptLabel = attempt.label ?? "translation";
                     logger.always(`[proxy:${format}] attempt ${attemptIndex + 1}/${attempts.length}: ${attempt.label}`);
@@ -295,10 +299,14 @@ export async function handleTranslatedStreamRequest(args) {
                                 }
                             }
                         }
+                        if (cancelled) {
+                            return;
+                        }
                         const toolCalls = streamResult.toolCalls ?? [];
                         if (!hasTranslatedOutput(collectedText, toolCalls)) {
                             finalStreamError = `Translated provider ${attempt.label} returned no content or tool calls`;
                             logger.debug(`${tag} translation attempt ${attempt.label} returned no content or tool calls`);
+                            recordAttemptError(lastAttemptLabel, "translation", 502);
                             continue;
                         }
                         if (!cancelled && toolCalls.length) {
@@ -331,7 +339,6 @@ export async function handleTranslatedStreamRequest(args) {
                         tracer?.recordMetrics();
                         translatedModel = streamResult.model;
                         succeeded = true;
-                        recordFinalSuccess(lastAttemptLabel, "translation");
                         return;
                     }
                     catch (streamErr) {
@@ -343,6 +350,8 @@ export async function handleTranslatedStreamRequest(args) {
                                 ? streamErr.message
                                 : String(streamErr);
                         if (collectedText.trim().length > 0) {
+                            streamInterruptedAfterOutput = true;
+                            recordAttemptError(lastAttemptLabel, "translation", 502);
                             logger.always(`${tag} mid-stream error: ${finalStreamError}`);
                             for (const frame of serializer.emitError(`Upstream stream interrupted: ${finalStreamError}`)) {
                                 controller.enqueue(encoder.encode(frame));
@@ -354,7 +363,6 @@ export async function handleTranslatedStreamRequest(args) {
                     }
                 }
                 // All attempts exhausted
-                recordFinalError(500, lastAttemptLabel, "translation");
                 if (!cancelled) {
                     logger.always(`${tag} all translation attempts failed: ${finalStreamError}`);
                     for (const frame of serializer.emitError(finalStreamError)) {
@@ -372,12 +380,38 @@ export async function handleTranslatedStreamRequest(args) {
                 if (tracer && translatedModel && translatedModel !== requestModel) {
                     tracer.setModelSubstitution(requestModel, translatedModel);
                 }
-                if (!succeeded) {
-                    tracer?.setError("generation_error", finalStreamError.slice(0, 500));
+                const terminalStatus = cancelled
+                    ? 499
+                    : succeeded
+                        ? 200
+                        : streamInterruptedAfterOutput
+                            ? 502
+                            : 500;
+                const terminalErrorType = cancelled
+                    ? "client_cancelled"
+                    : streamInterruptedAfterOutput
+                        ? "stream_error"
+                        : succeeded
+                            ? undefined
+                            : "generation_error";
+                const terminalErrorMessage = cancelled
+                    ? "Client cancelled the streaming response"
+                    : succeeded
+                        ? undefined
+                        : finalStreamError;
+                if (terminalErrorType && terminalErrorMessage) {
+                    tracer?.setError(terminalErrorType, terminalErrorMessage.slice(0, 500));
+                    recordFinalError(terminalStatus, lastAttemptLabel, "translation", {
+                        requestId: ctx.requestId,
+                        errorType: terminalErrorType,
+                        terminalOutcome: terminalErrorType,
+                        message: terminalErrorMessage,
+                    });
+                }
+                else {
+                    recordFinalSuccess(lastAttemptLabel, "translation");
                 }
-                // Use the real outcome status so trace data matches the logged
-                // responseStatus below (success path is 200, exhausted-attempts path is 500).
-                tracer?.end(succeeded ? 200 : 500, Date.now() - requestStartTime);
+                tracer?.end(terminalStatus, Date.now() - requestStartTime);
                 const traceCtx = tracer?.getTraceContext();
                 logRequest({
                     timestamp: new Date().toISOString(),
@@ -389,8 +423,12 @@ export async function handleTranslatedStreamRequest(args) {
                     toolCount: Object.keys(parsed.tools).length,
                     account: "translation",
                     accountType: "translation",
-                    responseStatus: succeeded ? 200 : 500,
+                    responseStatus: terminalStatus,
                     responseTimeMs: Date.now() - requestStartTime,
+                    ...(terminalErrorType ? { errorType: terminalErrorType } : {}),
+                    ...(terminalErrorMessage
+                        ? { errorMessage: terminalErrorMessage.slice(0, 500) }
+                        : {}),
                     ...(traceCtx?.traceId ? { traceId: traceCtx.traceId } : {}),
                     ...(traceCtx?.spanId ? { spanId: traceCtx.spanId } : {}),
                 });
@@ -424,7 +462,7 @@ export async function handleTranslatedStreamRequest(args) {
  * Handles a translated non-streaming request for either Claude or OpenAI format.
  */
 export async function handleTranslatedJsonRequest(args) {
-    const { ctx, format, requestModel, parsed, attempts, tracer, requestStartTime, } = args;
+    const { ctx, format, requestModel, parsed, attempts, tracer, requestStartTime, terminalFailureStatus = 500, } = args;
     const tag = logTag(format);
     let lastAttemptError = "No translation providers succeeded";
     let lastAttemptLabel = "translation";
@@ -448,6 +486,7 @@ export async function handleTranslatedJsonRequest(args) {
             if (!hasTranslatedOutput(collectedText, streamResult.toolCalls)) {
                 lastAttemptError = `Translated provider ${attempt.label} returned no content or tool calls`;
                 logger.debug(`${tag} translation attempt ${attempt.label} returned no content or tool calls`);
+                recordAttemptError(lastAttemptLabel, "translation", 502);
                 continue;
             }
             const internal = {
@@ -505,9 +544,14 @@ export async function handleTranslatedJsonRequest(args) {
             recordAttemptError(lastAttemptLabel, "translation", 500);
         }
     }
-    recordFinalError(500, lastAttemptLabel, "translation");
+    recordFinalError(terminalFailureStatus, lastAttemptLabel, "translation", {
+        requestId: ctx.requestId,
+        errorType: "generation_error",
+        terminalOutcome: "handler_error",
+        message: lastAttemptError,
+    });
     tracer?.setError("generation_error", lastAttemptError.slice(0, 500));
-    tracer?.end(500, Date.now() - requestStartTime);
+    tracer?.end(terminalFailureStatus, Date.now() - requestStartTime);
     const traceCtx = tracer?.getTraceContext();
     logRequest({
         timestamp: new Date().toISOString(),
@@ -519,7 +563,7 @@ export async function handleTranslatedJsonRequest(args) {
         toolCount: Object.keys(parsed.tools).length,
         account: "translation",
         accountType: "translation",
-        responseStatus: 500,
+        responseStatus: terminalFailureStatus,
         responseTimeMs: Date.now() - requestStartTime,
         errorType: "generation_error",
         errorMessage: lastAttemptError.slice(0, 500),

package/dist/proxy/rawStreamCapture.js

@@ -60,7 +60,11 @@ export function createRawStreamCapture() {
         },
     });
     const innerWriter = transform.writable.getWriter();
+    let writableController;
     const writable = new WritableStream({
+        start(controller) {
+            writableController = controller;
+        },
         write(chunk) {
             return innerWriter.write(chunk);
         },
@@ -72,9 +76,51 @@ export function createRawStreamCapture() {
             return innerWriter.abort(reason);
         },
     });
+    // A downstream reader cancellation errors the TransformStream's writable
+    // side, but this wrapper otherwise hides that state from the upstream pipe.
+    // Mirror it onto the wrapper so cancellation reaches the source reader.
+    void innerWriter.closed.catch((reason) => {
+        settle();
+        try {
+            writableController.error(reason);
+        }
+        catch {
+            // The wrapper may already be closing or aborted.
+        }
+    });
+    const innerReader = transform.readable.getReader();
+    const readable = new ReadableStream({
+        async pull(controller) {
+            try {
+                const { done, value } = await innerReader.read();
+                if (done) {
+                    controller.close();
+                }
+                else {
+                    controller.enqueue(value);
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            settle();
+            try {
+                writableController.error(reason);
+            }
+            catch {
+                // The wrapper may already be closing or aborted.
+            }
+            await Promise.allSettled([
+                innerReader.cancel(reason),
+                innerWriter.abort(reason),
+            ]);
+        },
+    });
     return {
         stream: {
-            readable: transform.readable,
+            readable,
             writable,
         },
         capture,

package/dist/proxy/requestLogger.d.ts

@@ -6,6 +6,8 @@
  * Useful for debugging and auditing proxy traffic.
  */
 import type { ProxyBodyCaptureEntry, RequestAttemptLogEntry, RequestLogEntry } from "../types/index.js";
+/** Wait, up to a bounded deadline, for admitted request/body writes to settle. */
+export declare function flushRequestLogs(timeoutMs?: number): Promise<void>;
 export declare function initRequestLogger(enabled?: boolean, customLogsDir?: string): void;
 export declare function logRequest(entry: RequestLogEntry): Promise<void>;
 /**