@juspay/neurolink 10.4.3 → 10.5.0

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;
@@ -1951,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;
@@ -1963,7 +2020,9 @@ export type StatusStats = {
         transientRateLimits?: number;
         quotaRateLimits?: number;
         cooling: boolean;
-        status?: "active" | "cooling" | "disabled" | "excluded" | "removed" | "unattributed";
+        allowed?: boolean;
+        expired?: boolean;
+        status?: "active" | "cooling" | "disabled" | "expired" | "excluded" | "removed" | "internal" | "unattributed";
     }[];
     persistence?: ProxyStatsPersistenceStatus;
 };

package/dist/lib/utils/fileDetector.js

@@ -23,6 +23,7 @@ async function getArchiveProcessor() {
 import { tracers, ATTR, withSpan } from "../telemetry/index.js";
 import { CSVProcessor } from "./csvProcessor.js";
 import { ImageProcessor } from "./imageProcessor.js";
+import { detectIsoBmffImageMimeType, hasFtypBoxSignature } from "./isoBmff.js";
 import { logger } from "./logger.js";
 import { withTimeout } from "./errorHandling.js";
 import { normalizeUrlForCache, redactUrlForError, sanitizeErrorCause, } from "./logSanitize.js";
@@ -1659,17 +1660,35 @@ class MagicBytesStrategy {
         if (this.isWebP(input)) {
             return this.result("image", "image/webp", 95);
         }
+        if (input.length >= 2 && input[0] === 0x42 && input[1] === 0x4d) {
+            return this.result("image", "image/bmp", 95);
+        }
+        if (input.length >= 4 &&
+            ((input[0] === 0x49 &&
+                input[1] === 0x49 &&
+                input[2] === 0x2a &&
+                input[3] === 0x00) ||
+                (input[0] === 0x4d &&
+                    input[1] === 0x4d &&
+                    input[2] === 0x00 &&
+                    input[3] === 0x2a))) {
+            return this.result("image", "image/tiff", 95);
+        }
+        if (input.length >= 4 &&
+            input[0] === 0x00 &&
+            input[1] === 0x00 &&
+            input[2] === 0x01 &&
+            input[3] === 0x00 &&
+            !hasFtypBoxSignature(input)) {
+            return this.result("image", "image/x-icon", 95);
+        }
         if (this.isPDF(input)) {
             return this.result("pdf", "application/pdf", 95);
         }
         // ISO-BMFF ("ftyp" at offset 4): MP4 video, QuickTime MOV, or M4A/M4B/M4P
         // audio all share this box — disambiguate by the major brand at offset 8-11,
         // otherwise an .m4a audio file is misrouted to the video pipeline.
-        if (input.length >= 8 &&
-            input[4] === 0x66 &&
-            input[5] === 0x74 &&
-            input[6] === 0x79 &&
-            input[7] === 0x70) {
+        if (hasFtypBoxSignature(input)) {
             const brand = input.length >= 12 ? input.toString("latin1", 8, 12) : "";
             // AVIF images share the ISO-BMFF ftyp box with MP4/MOV; the major brand
             // ('avif' still, 'avis' sequence, 'avio' intra-only AV1 image/sequence
@@ -1677,8 +1696,9 @@ class MagicBytesStrategy {
             // major_brand by real encoders) distinguishes them. Detect before the
             // audio/video branches so an AVIF buffer isn't misrouted to the video
             // pipeline (#286).
-            if (/^(avif|avis|avio)/.test(brand)) {
-                return this.result("image", "image/avif", 95);
+            const imageMimeType = detectIsoBmffImageMimeType(input);
+            if (imageMimeType) {
+                return this.result("image", imageMimeType, 95);
             }
             if (/^(M4A|M4B|M4P|F4A|F4B)/.test(brand)) {
                 return this.result("audio", "audio/mp4", 95);
@@ -1775,6 +1795,16 @@ class MagicBytesStrategy {
         if (input.length >= 2 && input[0] === 0x1f && input[1] === 0x8b) {
             return this.result("archive", "application/gzip", 90);
         }
+        // 7z: 37 7A BC AF 27 1C
+        if (input.length >= 6 &&
+            input[0] === 0x37 &&
+            input[1] === 0x7a &&
+            input[2] === 0xbc &&
+            input[3] === 0xaf &&
+            input[4] === 0x27 &&
+            input[5] === 0x1c) {
+            return this.result("archive", "application/x-7z-compressed", 95);
+        }
         // RAR: "Rar!"
         if (input.length >= 4 &&
             input[0] === 0x52 &&
@@ -2006,6 +2036,8 @@ class ExtensionStrategy {
             // AI providers don't support SVG format, so we process it as sanitized text
             svg: "svg",
             avif: "image",
+            heic: "image",
+            heif: "image",
             pdf: "pdf",
             // Video formats
             mp4: "video",
@@ -2179,6 +2211,8 @@ class ExtensionStrategy {
             tif: "image/tiff",
             svg: "image/svg+xml",
             avif: "image/avif",
+            heic: "image/heic",
+            heif: "image/heif",
             pdf: "application/pdf",
             // Video MIME types
             mp4: "video/mp4",

package/dist/lib/utils/imageProcessor.js

@@ -11,6 +11,7 @@ import { SYSTEM_LIMITS } from "../core/constants.js";
 import { SIZE_LIMITS_BYTES } from "../processors/config/sizeLimits.js";
 import { getImageCache } from "./imageCache.js";
 import { ErrorFactory, NeuroLinkError } from "./errorHandling.js";
+import { detectIsoBmffImageMimeType, hasFtypBoxSignature } from "./isoBmff.js";
 /**
  * Minimum bytes required just to detect an image format from magic bytes (#293).
  */
@@ -104,7 +105,7 @@ function isRetryableDownloadError(error) {
 }
 /**
  * Reject `detectImageType()`'s `application/octet-stream` sentinel — the
- * honest "no known image signature (PNG/JPEG/GIF/WebP/BMP/TIFF/SVG/AVIF)
+ * honest "no known image signature (PNG/JPEG/GIF/WebP/BMP/TIFF/ICO/SVG/AVIF/HEIC/HEIF)
  * matched" fallback (#261/#286). Packaging that sentinel into a data URI
  * hands vision providers (OpenAI/Anthropic/Google) a MIME type they reject
  * outright with an HTTP 400, so every public conversion path that turns
@@ -118,7 +119,7 @@ function assertKnownImageType(mediaType) {
     if (mediaType === "application/octet-stream") {
         logger.error("Unable to detect a supported image format from file content");
         throw new Error("Unsupported or corrupted image: no known image signature " +
-            "(PNG/JPEG/GIF/WebP/BMP/TIFF/SVG/AVIF) was found in the file content.");
+            "(PNG/JPEG/GIF/WebP/BMP/TIFF/ICO/SVG/AVIF/HEIC/HEIF) was found in the file content.");
     }
 }
 /**
@@ -457,24 +458,22 @@ export class ImageProcessor {
                         return "image/svg+xml";
                     }
                 }
-                // AVIF (ISOBMFF): "ftyp" box at offset 4, major brand at offset 8.
-                // Accept the AVIF-spec brand variants — 'avif' (still image), 'avis'
-                // (image sequence), and 'avio' (intra-only AV1 image/sequence — the
-                // spec lists it under compatible_brands rather than major_brand, but
-                // real-world encoders emit it as major_brand too, so it's accepted
-                // here) — and compare bytes directly rather than via Buffer.toString()
-                // (which would utf-8-decode non-ASCII bytes) so the check is exact
-                // (#286).
-                if (input.length >= 12) {
-                    const isFtyp = input[4] === 0x66 && // 'f'
-                        input[5] === 0x74 && // 't'
-                        input[6] === 0x79 && // 'y'
-                        input[7] === 0x70; // 'p'
-                    const brand = String.fromCharCode(input[8], input[9], input[10], input[11]);
-                    if (isFtyp &&
-                        (brand === "avif" || brand === "avis" || brand === "avio")) {
-                        return "image/avif";
-                    }
+                // ISO-BMFF images: "ftyp" box at offset 4, major brand at offset 8.
+                // AVIF has codec-specific major brands. HEIC uses HEVC image/sequence
+                // brands, while generic HEIF structural brands (mif1/msf1) need a
+                // compatible codec brand to avoid mistaking AVIF or generic MP4 data
+                // for HEIF.
+                const isoBmffMimeType = detectIsoBmffImageMimeType(input);
+                if (isoBmffMimeType) {
+                    return isoBmffMimeType;
+                }
+                // ICO: 00 00 01 00 (icon type=1)
+                if (input[0] === 0x00 &&
+                    input[1] === 0x00 &&
+                    input[2] === 0x01 &&
+                    input[3] === 0x00 &&
+                    !hasFtypBoxSignature(input)) {
+                    return "image/x-icon";
                 }
                 // BMP: "BM" magic (0x42 0x4D)
                 if (input[0] === 0x42 && input[1] === 0x4d) {

package/dist/lib/utils/isoBmff.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared ISO-BMFF (`ftyp`) image-brand detection.
+ *
+ * FileDetector and ImageProcessor must use the same brand tables and declared
+ * box boundary when classifying AVIF, HEIC, and structural HEIF brands. Keeping
+ * the scan here prevents the two consumers from drifting as new brands are
+ * added.
+ */
+export declare const AVIF_FTYP_BRANDS: Set<string>;
+export declare const HEIC_FTYP_BRANDS: Set<string>;
+export declare const HEIF_STRUCTURAL_FTYP_BRANDS: Set<string>;
+/**
+ * Whether the buffer starts with an ISO-BMFF `ftyp` box signature.
+ */
+export declare function hasFtypBoxSignature(input: Buffer): boolean;
+/**
+ * Read compatible brands without scanning past the declared `ftyp` box.
+ */
+export declare function getCompatibleFtypBrands(input: Buffer): Set<string>;
+/**
+ * Return the image MIME type encoded by an ISO-BMFF `ftyp` box, or null when
+ * the box belongs to a non-image ISO-BMFF flavor.
+ */
+export declare function detectIsoBmffImageMimeType(input: Buffer): string | null;

package/dist/lib/utils/isoBmff.js

@@ -0,0 +1,83 @@
+/**
+ * Shared ISO-BMFF (`ftyp`) image-brand detection.
+ *
+ * FileDetector and ImageProcessor must use the same brand tables and declared
+ * box boundary when classifying AVIF, HEIC, and structural HEIF brands. Keeping
+ * the scan here prevents the two consumers from drifting as new brands are
+ * added.
+ */
+export const AVIF_FTYP_BRANDS = new Set(["avif", "avis", "avio"]);
+export const HEIC_FTYP_BRANDS = new Set([
+    "heic",
+    "heix",
+    "hevc",
+    "hevx",
+    "heim",
+    "heis",
+    "hevm",
+    "hevs",
+]);
+export const HEIF_STRUCTURAL_FTYP_BRANDS = new Set(["mif1", "msf1"]);
+/**
+ * Whether the buffer starts with an ISO-BMFF `ftyp` box signature.
+ */
+export function hasFtypBoxSignature(input) {
+    return (input.length >= 8 &&
+        input[4] === 0x66 &&
+        input[5] === 0x74 &&
+        input[6] === 0x79 &&
+        input[7] === 0x70);
+}
+/**
+ * Read compatible brands without scanning past the declared `ftyp` box.
+ */
+export function getCompatibleFtypBrands(input) {
+    const compatibleBrands = new Set();
+    if (input.length < 20) {
+        return compatibleBrands;
+    }
+    const declaredBoxSize = input.readUInt32BE(0);
+    const boxEnd = declaredBoxSize === 0
+        ? input.length
+        : Math.min(input.length, declaredBoxSize);
+    for (let offset = 16; offset + 4 <= boxEnd; offset += 4) {
+        compatibleBrands.add(input.toString("latin1", offset, offset + 4));
+    }
+    return compatibleBrands;
+}
+function hasFtypBrand(compatibleBrands, candidates) {
+    for (const brand of compatibleBrands) {
+        if (candidates.has(brand)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Return the image MIME type encoded by an ISO-BMFF `ftyp` box, or null when
+ * the box belongs to a non-image ISO-BMFF flavor.
+ */
+export function detectIsoBmffImageMimeType(input) {
+    if (input.length < 12 || !hasFtypBoxSignature(input)) {
+        return null;
+    }
+    const brand = input.toString("latin1", 8, 12);
+    if (AVIF_FTYP_BRANDS.has(brand)) {
+        return "image/avif";
+    }
+    if (HEIC_FTYP_BRANDS.has(brand)) {
+        return "image/heic";
+    }
+    if (!HEIF_STRUCTURAL_FTYP_BRANDS.has(brand)) {
+        return null;
+    }
+    const compatibleBrands = getCompatibleFtypBrands(input);
+    if (hasFtypBrand(compatibleBrands, HEIC_FTYP_BRANDS)) {
+        return "image/heif";
+    }
+    if (hasFtypBrand(compatibleBrands, AVIF_FTYP_BRANDS)) {
+        return "image/avif";
+    }
+    return null;
+}
+//# sourceMappingURL=isoBmff.js.map

package/dist/processors/config/mimeConstants.js

@@ -283,6 +283,8 @@ export const EXTENSION_MIME_MAP = {
     ".webp": IMAGE_MIME_TYPES.WEBP,
     ".bmp": IMAGE_MIME_TYPES.BMP,
     ".ico": IMAGE_MIME_TYPES.ICO,
+    ".heic": IMAGE_MIME_TYPES.HEIC,
+    ".heif": IMAGE_MIME_TYPES.HEIF,
     // Source code
     ".js": TEXT_MIME_TYPES.JAVASCRIPT,
     ".mjs": TEXT_MIME_TYPES.JAVASCRIPT,

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,