@juspay/neurolink 12.14.6 → 12.14.8

package/dist/proxy/codexUsage.js

@@ -45,6 +45,36 @@ import { sanitizeForLog } from "../utils/logSanitize.js";
 const nonNegativeInt = (value) => typeof value === "number" && Number.isFinite(value) && value > 0
     ? Math.floor(value)
     : 0;
+function usefulOutputItem(item) {
+    if (!item || typeof item !== "object") {
+        return false;
+    }
+    if ("type" in item) {
+        if (item.type === "function_call") {
+            return ("arguments" in item &&
+                typeof item.arguments === "string" &&
+                item.arguments.trim().length > 0);
+        }
+        if (item.type === "custom_tool_call") {
+            return ("input" in item &&
+                typeof item.input === "string" &&
+                item.input.trim().length > 0);
+        }
+        if (item.type === "output_text") {
+            return ("text" in item &&
+                typeof item.text === "string" &&
+                item.text.trim().length > 0);
+        }
+        if (item.type === "refusal") {
+            return ("refusal" in item &&
+                typeof item.refusal === "string" &&
+                item.refusal.trim().length > 0);
+        }
+    }
+    return ("content" in item &&
+        Array.isArray(item.content) &&
+        item.content.some(usefulOutputItem));
+}
 /**
  * Pull usage out of one parsed SSE `data:` payload.
  *
@@ -125,7 +155,7 @@ const CAPTURE_LIMIT_BYTES = 256 * 1024;
  */
 function createCaptureSink() {
     const target = process.env.NEUROLINK_PROXY_CODEX_CAPTURE;
-    if (!target) {
+    if (!target || process.env.NEUROLINK_PROXY_LOG_SINK === "otel") {
         return null;
     }
     let written = 0;
@@ -167,9 +197,13 @@ export function createCodexUsageTap() {
     let totalBytes = 0;
     const inspectEvidence = (events) => {
         for (const frame of events) {
+            if (frame.data.trim() === "[DONE]") {
+                continue;
+            }
             try {
                 const event = JSON.parse(frame.data);
                 if (!event || typeof event !== "object") {
+                    evidence.observationIncomplete = true;
                     continue;
                 }
                 const seen = extractCodexUsage(event);
@@ -178,10 +212,53 @@ export function createCodexUsageTap() {
                 }
                 const type = event.type ?? frame.event;
                 if ((type === "response.output_text.delta" ||
+                    type === "response.refusal.delta" ||
                     type === "response.function_call_arguments.delta") &&
                     typeof event.delta === "string" &&
-                    event.delta.length > 0) {
-                    evidence.firstUsefulOutputAt ??= Date.now();
+                    event.delta.trim().length > 0) {
+                    if (evidence.firstUsefulOutputAt === undefined) {
+                        evidence.firstUsefulOutputAt = Date.now();
+                        evidence.firstUsefulOutputEvent = String(type);
+                    }
+                }
+                // Some clients/providers emit complete output items without deltas.
+                // Reasoning/control events are not useful client output. Recognize
+                // actual tool calls and text only, without inventing an earlier time.
+                const usefulItem = usefulOutputItem(event.item);
+                const completedResponse = event.response;
+                const usefulCompletion = type === "response.completed" &&
+                    completedResponse &&
+                    typeof completedResponse === "object" &&
+                    "output" in completedResponse &&
+                    Array.isArray(completedResponse.output) &&
+                    completedResponse.output.some(usefulOutputItem);
+                const usefulDone = (type === "response.output_text.done" &&
+                    typeof event.text === "string" &&
+                    event.text.trim().length > 0) ||
+                    (type === "response.refusal.done" &&
+                        typeof event.refusal === "string" &&
+                        event.refusal.trim().length > 0) ||
+                    (type === "response.function_call_arguments.done" &&
+                        typeof event.arguments === "string" &&
+                        event.arguments.trim().length > 0) ||
+                    (type === "response.custom_tool_call_input.done" &&
+                        typeof event.input === "string" &&
+                        event.input.trim().length > 0) ||
+                    ((type === "response.content_part.added" ||
+                        type === "response.content_part.done") &&
+                        usefulOutputItem(event.part));
+                const usefulToolDelta = type === "response.custom_tool_call_input.delta" &&
+                    typeof event.delta === "string" &&
+                    event.delta.trim().length > 0;
+                if (evidence.firstUsefulOutputAt === undefined &&
+                    (usefulDone ||
+                        usefulCompletion ||
+                        usefulToolDelta ||
+                        ((type === "response.output_item.added" ||
+                            type === "response.output_item.done") &&
+                            usefulItem))) {
+                    evidence.firstUsefulOutputAt = Date.now();
+                    evidence.firstUsefulOutputEvent = String(type);
                 }
                 if (type === "response.completed") {
                     evidence.completed = true;
@@ -222,6 +299,7 @@ export function createCodexUsageTap() {
             }
             catch {
                 // Unknown frames cannot establish successful completion.
+                evidence.observationIncomplete = true;
             }
         }
     };
@@ -268,16 +346,21 @@ export function createCodexUsageTap() {
                 carry = remainder;
                 inspectEvidence(events);
                 if (carry.length > CARRY_LIMIT_CHARS) {
+                    evidence.observationIncomplete = true;
                     carry = carry.slice(-2);
                     discardingEvent = true;
                 }
             }
             catch {
                 // Telemetry must never break the relay.
+                evidence.observationIncomplete = true;
             }
         },
         flush() {
             // An event without its dispatch delimiter is incomplete on the wire.
+            if (discardingEvent || carry.trim()) {
+                evidence.observationIncomplete = true;
+            }
             settle(latest);
         },
         /**

package/dist/proxy/otelLogSink.d.ts

@@ -34,6 +34,18 @@ export declare function getProxyOtelLogSnapshot(): {
         maxPendingBytes: number;
     };
     queues: {
+        recentFailures: {
+            records: {
+                eventId: string;
+                kind?: string;
+                requestId?: string;
+                captureId?: string;
+            }[];
+            id: string;
+            at: string;
+            reason: "export_unconfirmed" | "queue_full";
+            error?: string;
+        }[];
         attempted: number;
         submitted: number;
         transportAcknowledged: number;
@@ -43,6 +55,7 @@ export declare function getProxyOtelLogSnapshot(): {
         lastAcknowledgedAt: string | undefined;
         lastFailureAt: string | undefined;
         highWaterOutstanding: number;
+        failureHistoryEvicted: number;
         kind: "metadata" | "bodies";
         capacity: number;
     }[];

package/dist/proxy/otelLogSink.js

@@ -1,5 +1,7 @@
 /* eslint-disable no-console -- This proxy-only sink replaces console methods with OTLP emission. */
 import { inspect } from "node:util";
+import { randomUUID } from "node:crypto";
+import { getProxyRequestTraceContext, proxyLogContext, } from "./proxyTraceContext.js";
 import { setImmediate as yieldToRequests } from "node:timers/promises";
 import { SeverityNumber } from "@opentelemetry/api-logs";
 import { ExportResultCode } from "@opentelemetry/core";
@@ -24,7 +26,7 @@ const bodyDelivery = {
     pendingBytes: 0,
     highWaterPending: 0,
     highWaterBytes: 0,
-    maxPending: 16,
+    maxPending: 64,
     maxPendingBytes: 32 * 1024 * 1024,
 };
 /** Explicit opt-in; configuration never silently falls back to file logging. */
@@ -45,6 +47,52 @@ function createTrackedProcessor(url, capacity, kind) {
         lastAcknowledgedAt: undefined,
         lastFailureAt: undefined,
         highWaterOutstanding: 0,
+        recentFailures: [],
+        failureHistoryEvicted: 0,
+    };
+    const diagnostics = [];
+    let diagnosticScheduled = false;
+    const rememberFailure = (records, reason, error) => {
+        const stringAttribute = (record, name) => {
+            const value = record.attributes[name];
+            return typeof value === "string" ? value.slice(0, 128) : undefined;
+        };
+        const failure = {
+            id: randomUUID(),
+            at: new Date().toISOString(),
+            reason,
+            ...(error ? { error: sanitizeForLog(error.message).slice(0, 256) } : {}),
+            records: records.slice(0, 64).map((record) => ({
+                eventId: stringAttribute(record, "proxy.event_id") ?? "unavailable",
+                kind: stringAttribute(record, "proxy.record_kind"),
+                requestId: stringAttribute(record, "request.id"),
+                captureId: stringAttribute(record, "body.capture_id"),
+            })),
+        };
+        if (state.recentFailures.length === 16) {
+            state.recentFailures.shift();
+            state.failureHistoryEvicted++;
+        }
+        state.recentFailures.push(failure);
+        // A failed diagnostic must not generate another diagnostic recursively.
+        if (records.some((record) => record.attributes["proxy.record_kind"] !== "telemetry_delivery")) {
+            if (diagnostics.length === 16) {
+                diagnostics.shift();
+            }
+            diagnostics.push(failure);
+        }
+    };
+    const publishRecoveredDiagnostics = () => {
+        if (diagnosticScheduled || !diagnostics.length || shuttingDown) {
+            return;
+        }
+        diagnosticScheduled = true;
+        queueMicrotask(() => {
+            diagnosticScheduled = false;
+            for (const failure of diagnostics.splice(0)) {
+                emitProxyOtelEvent("telemetry_delivery", { queue: kind, ...failure });
+            }
+        });
     };
     const transport = new OTLPLogExporter({ url, timeoutMillis: 5000 });
     const exporter = {
@@ -65,10 +113,12 @@ function createTrackedProcessor(url, capacity, kind) {
                 if (result.code === ExportResultCode.SUCCESS) {
                     state.transportAcknowledged += records.length;
                     state.lastAcknowledgedAt = new Date().toISOString();
+                    publishRecoveredDiagnostics();
                 }
                 else {
                     state.exportUnconfirmed += records.length;
                     state.lastFailureAt = new Date().toISOString();
+                    rememberFailure(records, "export_unconfirmed", result.error);
                 }
                 for (const record of records) {
                     unsettled.delete(record);
@@ -109,6 +159,7 @@ function createTrackedProcessor(url, capacity, kind) {
     });
     const processor = {
         onEmit(record) {
+            record.attributes["proxy.event_id"] ??= randomUUID();
             state.attempted++;
             const id = record.attributes?.["body.capture_id"];
             const publication = typeof id === "string" ? bodyPublications.get(id) : undefined;
@@ -117,6 +168,7 @@ function createTrackedProcessor(url, capacity, kind) {
             }
             if (state.outstanding >= capacity) {
                 state.dropped++;
+                rememberFailure([record], "queue_full");
                 if (publication) {
                     publication.dropped++;
                     publication.notify?.();
@@ -355,12 +407,17 @@ export function emitProxyOtelEvent(kind, record) {
         return;
     }
     try {
+        const ids = typeof record.requestId === "string" && !record.traceId
+            ? getProxyRequestTraceContext(record.requestId)
+            : undefined;
+        const correlated = ids ? { ...record, ...ids } : record;
         initializeProxyOtelLogs()
             ?.getLogger("neurolink-proxy-events")
             .emit({
+            context: proxyLogContext(correlated),
             severityNumber: SeverityNumber.INFO,
             severityText: "INFO",
-            body: JSON.stringify(record),
+            body: JSON.stringify(correlated),
             attributes: {
                 "proxy.record_kind": kind,
                 "event.name": `proxy.${kind}`,
@@ -444,6 +501,10 @@ export function getProxyOtelLogSnapshot() {
             kind: q.kind,
             capacity: q.capacity,
             ...q.state,
+            recentFailures: q.state.recentFailures.map((failure) => ({
+                ...failure,
+                records: failure.records.map((record) => ({ ...record })),
+            })),
         })),
     };
 }

package/dist/proxy/processTelemetry.d.ts

@@ -0,0 +1,3 @@
+import type { ProxyProcessTelemetrySnapshot } from "../types/index.js";
+/** Inspect this process, not the launcher configuration intended for its successor. */
+export declare function getProxyProcessTelemetry(): ProxyProcessTelemetrySnapshot;

package/dist/proxy/processTelemetry.js

@@ -0,0 +1,25 @@
+import { fstatSync } from "node:fs";
+import { getProxyOtelLogSnapshot, isProxyOtelOnly } from "./otelLogSink.js";
+import { getProxyLifecycleLoggerSnapshot } from "./proxyLifecycle.js";
+/** Inspect this process, not the launcher configuration intended for its successor. */
+export function getProxyProcessTelemetry() {
+    const descriptor = (fd) => {
+        try {
+            return fstatSync(fd).isFile() ? "file" : "non_file";
+        }
+        catch {
+            return "unavailable";
+        }
+    };
+    const logs = getProxyOtelLogSnapshot();
+    return {
+        pid: process.pid,
+        checkedAt: new Date().toISOString(),
+        configuredSink: isProxyOtelOnly() ? "otel" : "file",
+        lifecycleSink: getProxyLifecycleLoggerSnapshot().sink ?? "unavailable",
+        otelInitialized: logs.initialized,
+        stdio: { stdout: descriptor(1), stderr: descriptor(2) },
+        exportDropped: logs.queues.reduce((n, q) => n + q.dropped, 0),
+        exportUnconfirmed: logs.queues.reduce((n, q) => n + q.exportUnconfirmed, 0),
+    };
+}

package/dist/proxy/proxyTraceContext.d.ts

@@ -0,0 +1,21 @@
+import type { ProxyLogTraceContext } from "../types/index.js";
+/** Correlation belongs to the in-flight HTTP request, not to an async callback. */
+export declare function registerProxyRequestTraceContext(requestId: string, ids: ProxyLogTraceContext): void;
+/** Release once transport and terminal accounting have settled. */
+export declare function releaseProxyRequestTraceContext(requestId: string): void;
+/** Internal fallback records share their parent request's trace. */
+export declare function getProxyRequestTraceContext(requestId: string): ProxyLogTraceContext | undefined;
+/** Retain IDs and sampling flags before deferred processing leaves the request. */
+export declare function resolveProxyLogTraceContext(record: {
+    traceId?: unknown;
+    spanId?: unknown;
+    traceFlags?: unknown;
+    requestId?: unknown;
+}): ProxyLogTraceContext | undefined;
+/** Populate native OTLP correlation, including valid unsampled contexts. */
+export declare function proxyLogContext(record: {
+    traceId?: unknown;
+    spanId?: unknown;
+    traceFlags?: unknown;
+    requestId?: unknown;
+}): import("@opentelemetry/api").Context;

package/dist/proxy/proxyTraceContext.js

@@ -0,0 +1,47 @@
+import { context, ROOT_CONTEXT, trace, isSpanContextValid, } from "@opentelemetry/api";
+const requests = new Map();
+/** Correlation belongs to the in-flight HTTP request, not to an async callback. */
+export function registerProxyRequestTraceContext(requestId, ids) {
+    requests.set(requestId, ids);
+}
+/** Release once transport and terminal accounting have settled. */
+export function releaseProxyRequestTraceContext(requestId) {
+    requests.delete(requestId);
+}
+/** Internal fallback records share their parent request's trace. */
+export function getProxyRequestTraceContext(requestId) {
+    return (requests.get(requestId) ??
+        requests.get(requestId.replace(/:codex-fallback$/, "")));
+}
+/** Retain IDs and sampling flags before deferred processing leaves the request. */
+export function resolveProxyLogTraceContext(record) {
+    const saved = typeof record.requestId === "string"
+        ? getProxyRequestTraceContext(record.requestId)
+        : undefined;
+    const active = trace.getSpanContext(context.active());
+    const ids = typeof record.traceId === "string" && typeof record.spanId === "string"
+        ? { traceId: record.traceId, spanId: record.spanId }
+        : (saved ?? active);
+    if (!ids) {
+        return undefined;
+    }
+    const traceFlags = typeof record.traceFlags === "number" &&
+        Number.isInteger(record.traceFlags) &&
+        record.traceFlags >= 0 &&
+        record.traceFlags <= 255
+        ? record.traceFlags
+        : saved?.traceId === ids.traceId
+            ? saved.traceFlags
+            : active?.traceId === ids.traceId
+                ? active.traceFlags
+                : 0;
+    const result = { ...ids, traceFlags };
+    return isSpanContextValid(result)
+        ? { traceId: result.traceId, spanId: result.spanId, traceFlags }
+        : undefined;
+}
+/** Populate native OTLP correlation, including valid unsampled contexts. */
+export function proxyLogContext(record) {
+    const ids = resolveProxyLogTraceContext(record);
+    return ids ? trace.setSpanContext(ROOT_CONTEXT, ids) : context.active();
+}

package/dist/proxy/proxyTracer.d.ts

@@ -14,7 +14,7 @@
  * - TelemetryService for metrics recording
  */
 import { type Span } from "@opentelemetry/api";
-import type { AccountSelectionContext, ProxyRequestContext, ResponseInfoContext, UpstreamAttemptContext, UsageContext } from "../types/index.js";
+import type { AccountSelectionContext, ProxyRequestContext, ResponseInfoContext, UpstreamAttemptContext, UsageContext, RuntimeRequestMetadata, ProxyLogTraceContext } from "../types/index.js";
 declare class ProxyTracer {
     private readonly rootSpan;
     private readonly proxyTracer;
@@ -34,6 +34,8 @@ declare class ProxyTracer {
     private billingProvider;
     private readonly startTime;
     private readonly isStream;
+    private ended;
+    private recordRequestMetrics;
     private accountEmail?;
     private usage?;
     private mode;
@@ -102,10 +104,7 @@ declare class ProxyTracer {
     /** Record request and/or response body sizes for bandwidth tracking. */
     recordBodySizes(requestBytes?: number, responseBytes?: number): void;
     /** Return the OTel trace/span IDs for this request (for log correlation). */
-    getTraceContext(): {
-        traceId: string;
-        spanId: string;
-    };
+    getTraceContext(): ProxyLogTraceContext;
     /** Return the captured usage (set by setUsage). */
     getUsage(): UsageContext | undefined;
     /** End the root span with final HTTP status and duration, and emit OTEL metrics. */
@@ -126,3 +125,8 @@ export declare function recordFallbackAttempt(attrs: {
     durationMs: number;
 }): void;
 export { ProxyTracer };
+/** Standard SERVER span covers every proxy door, including parsing and admission failures. */
+export declare function startProxyHttpTrace(metadata: RuntimeRequestMetadata, headers: Record<string, string>): {
+    run: <T>(fn: () => T) => T;
+    end: (status: number, outcome: string, errorType?: string) => void;
+};

package/dist/proxy/proxyTracer.js

@@ -13,12 +13,13 @@
  * - calculateCost() from pricing.ts for cost tracking
  * - TelemetryService for metrics recording
  */
-import { SpanStatusCode, context, metrics, trace, } from "@opentelemetry/api";
+import { SpanStatusCode, SpanKind, ROOT_CONTEXT, isSpanContextValid, propagation, context, metrics, trace, } from "@opentelemetry/api";
 import { getTracer, setLangfuseContext, } from "../services/server/ai/observability/instrumentation.js";
 import { OtelBridge } from "../observability/otelBridge.js";
 import { calculateCost } from "../utils/pricing.js";
 import { TelemetryService } from "../telemetry/telemetryService.js";
 import { logger } from "../utils/logger.js";
+import { registerProxyRequestTraceContext, releaseProxyRequestTraceContext, } from "./proxyTraceContext.js";
 const LOG_PREFIX = "[ProxyTracer]";
 // ---------------------------------------------------------------------------
 // OTEL Metric Instruments — lazy singleton
@@ -205,6 +206,8 @@ class ProxyTracer {
     billingProvider;
     startTime;
     isStream;
+    ended = false;
+    recordRequestMetrics = true;
     accountEmail;
     usage;
     mode = "full";
@@ -226,7 +229,7 @@ class ProxyTracer {
         const tracer = getTracer("neurolink.proxy");
         // Extract parent context from incoming headers (Claude Code may send traceparent)
         let parentContext = context.active();
-        if (incomingHeaders) {
+        if (incomingHeaders && !trace.getSpan(context.active())) {
             const bridge = new OtelBridge();
             const extracted = bridge.extractContext(incomingHeaders);
             if (extracted) {
@@ -270,6 +273,7 @@ class ProxyTracer {
             rootSpan.setAttribute("neurolink.conversation_id", nlConversationId);
         }
         const instance = new ProxyTracer(rootSpan, ctx.requestId, ctx.model, ctx.stream, ctx.provider ?? "anthropic");
+        instance.recordRequestMetrics = ctx.recordRequestMetrics !== false;
         // Set Langfuse context (fire-and-forget — non-blocking)
         // Prefer NeuroLink session/user from calling SDK over Claude Code session
         setLangfuseContext({
@@ -607,6 +611,7 @@ class ProxyTracer {
         return {
             traceId: spanCtx.traceId,
             spanId: spanCtx.spanId,
+            traceFlags: spanCtx.traceFlags,
         };
     }
     /** Return the captured usage (set by setUsage). */
@@ -618,6 +623,10 @@ class ProxyTracer {
     // -------------------------------------------------------------------------
     /** End the root span with final HTTP status and duration, and emit OTEL metrics. */
     end(responseStatus, durationMs) {
+        if (this.ended) {
+            return;
+        }
+        this.ended = true;
         this.rootSpan.setAttributes({
             "http.status_code": responseStatus,
             "proxy.duration_ms": durationMs,
@@ -636,6 +645,9 @@ class ProxyTracer {
             this.rootSpan.setStatus({ code: SpanStatusCode.OK });
         }
         this.rootSpan.end();
+        if (!this.recordRequestMetrics) {
+            return;
+        }
         // ---- Emit OTEL metrics (lazy-init instruments) ----
         const m = getProxyMetrics();
         const labels = {
@@ -745,3 +757,70 @@ export function recordFallbackAttempt(attrs) {
     }
 }
 export { ProxyTracer };
+/** Standard SERVER span covers every proxy door, including parsing and admission failures. */
+export function startProxyHttpTrace(metadata, headers) {
+    try {
+        // Match OtelBridge's existing compatibility policy for HTTP-combined
+        // traceparent values: retain the first injected parent.
+        const normalizedHeaders = { ...headers };
+        if (normalizedHeaders.traceparent?.includes(",")) {
+            normalizedHeaders.traceparent = normalizedHeaders.traceparent
+                .split(",", 1)[0]
+                .trim();
+        }
+        const parent = propagation.extract(ROOT_CONTEXT, normalizedHeaders);
+        const span = getTracer("neurolink.proxy").startSpan("proxy.http.request", {
+            kind: SpanKind.SERVER,
+            attributes: {
+                "http.request.method": metadata.method,
+                "url.path": metadata.path,
+                "proxy.request_id": metadata.requestId,
+            },
+        }, parent);
+        const spanContext = span.spanContext();
+        if (isSpanContextValid(spanContext)) {
+            metadata.traceId = spanContext.traceId;
+            metadata.spanId = spanContext.spanId;
+            metadata.traceFlags = spanContext.traceFlags;
+            registerProxyRequestTraceContext(metadata.requestId, {
+                traceId: spanContext.traceId,
+                spanId: spanContext.spanId,
+                traceFlags: spanContext.traceFlags,
+            });
+        }
+        const active = trace.setSpan(parent, span);
+        let ended = false;
+        return {
+            run: (fn) => context.with(active, fn),
+            end: (status, outcome, errorType) => {
+                if (ended) {
+                    return;
+                }
+                ended = true;
+                try {
+                    span.setAttributes({
+                        "http.response.status_code": status,
+                        "proxy.terminal_outcome": outcome,
+                        ...(errorType ? { "error.type": errorType } : {}),
+                    });
+                    if (status >= 500 ||
+                        outcome === "stream_error" ||
+                        outcome === "unknown") {
+                        span.setStatus({ code: SpanStatusCode.ERROR });
+                    }
+                    span.end();
+                }
+                catch {
+                    // Telemetry must not interrupt transport cleanup.
+                }
+                finally {
+                    releaseProxyRequestTraceContext(metadata.requestId);
+                }
+            },
+        };
+    }
+    catch {
+        releaseProxyRequestTraceContext(metadata.requestId);
+        return { run: (fn) => fn(), end: () => undefined };
+    }
+}

package/dist/proxy/rawStreamCapture.js

@@ -1,5 +1,9 @@
 /** Maximum bytes to capture before stopping accumulation (1 MB). */
 const MAX_CAPTURE_BYTES = 1024 * 1024;
+// Payload accounting across concurrent stream observers, independent of the
+// worker's clone/publication pool. Never retain an unbounded number of prefixes.
+const MAX_PENDING_CAPTURE_BYTES = 16 * 1024 * 1024;
+let pendingCaptureBytes = 0;
 const TRUNCATION_MARKER = "\n...[TRUNCATED]";
 export function createRawStreamCapture() {
     const decoder = new TextDecoder();
@@ -17,21 +21,13 @@ export function createRawStreamCapture() {
             return;
         }
         resolved = true;
-        const finalChunk = decoder.decode();
-        if (finalChunk) {
-            if (capturedBytes < MAX_CAPTURE_BYTES) {
-                const remainingBytes = MAX_CAPTURE_BYTES - capturedBytes;
-                chunks.push(finalChunk.slice(0, remainingBytes));
-                capturedBytes += Math.min(finalChunk.length, remainingBytes);
-            }
-            else if (!truncated) {
-                chunks.push(TRUNCATION_MARKER);
-                truncated = true;
-            }
-        }
+        const text = chunks.map((chunk) => decoder.decode(chunk, { stream: true })).join("") +
+            (truncated ? "" : decoder.decode());
+        pendingCaptureBytes -= capturedBytes;
+        chunks.length = 0;
         resolveCapture({
             totalBytes,
-            text: chunks.join(""),
+            text: text + (truncated ? TRUNCATION_MARKER : ""),
             truncated,
         });
     }
@@ -39,21 +35,16 @@ export function createRawStreamCapture() {
         transform(chunk, controller) {
             controller.enqueue(chunk);
             totalBytes += chunk.byteLength;
-            if (capturedBytes < MAX_CAPTURE_BYTES) {
-                const decoded = decoder.decode(chunk, { stream: true });
-                const remainingBytes = MAX_CAPTURE_BYTES - capturedBytes;
-                const slice = decoded.slice(0, remainingBytes);
+            if (!truncated && capturedBytes < MAX_CAPTURE_BYTES) {
+                const remainingBytes = Math.min(MAX_CAPTURE_BYTES - capturedBytes, Math.max(0, MAX_PENDING_CAPTURE_BYTES - pendingCaptureBytes));
+                // Buffer.slice is a view; copy to avoid retaining the whole wire chunk.
+                const slice = Uint8Array.from(chunk.subarray(0, remainingBytes));
                 chunks.push(slice);
-                capturedBytes += Math.min(decoded.length, remainingBytes);
-                if (decoded.length > remainingBytes && !truncated) {
-                    chunks.push(TRUNCATION_MARKER);
-                    truncated = true;
-                }
-            }
-            else if (!truncated) {
-                chunks.push(TRUNCATION_MARKER);
-                truncated = true;
+                capturedBytes += slice.byteLength;
+                pendingCaptureBytes += slice.byteLength;
+                truncated = slice.byteLength < chunk.byteLength;
             }
+            truncated ||= totalBytes > MAX_CAPTURE_BYTES;
         },
         flush() {
             settle();

package/dist/proxy/requestLogger.d.ts

@@ -35,6 +35,8 @@ export declare function prepareProxyBodyForLogging(body: unknown): {
     truncated: boolean;
     originalBytes?: number;
 };
+/** Cheap gate for response observers; avoid copying diagnostics on the serving path. */
+export declare function isProxyBodyCaptureEnabled(): boolean;
 /** Capture an owned request body with bounded processing and tracked index/export publication. */
 export declare function logBodyCapture(entry: ProxyBodyCaptureEntry): Promise<void>;
 /**