@juspay/neurolink 12.14.4 → 12.14.5

package/dist/cli/commands/proxy.js

@@ -1079,6 +1079,8 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
         requestMetadata.set(c.req.raw, metadata);
         const stopObservingFinalLog = observeProxyFinalLog(metadata.requestId, (entry) => {
             metadata.terminalResult = entry;
+        }, (entry) => {
+            metadata.lastUpstreamAttempt = { ...entry };
         });
         const finishActivity = metadata.rejectForUpdate
             ? () => undefined
@@ -1306,7 +1308,8 @@ export async function createProxyStartApp(params) {
     const recordRuntimeError = async (metadata, status, errorType, errorMessage, options) => {
         const clientMessage = options?.clientMessage ?? errorMessage;
         const clientErrorType = options?.clientErrorType ?? errorType;
-        recordFinalError(status, PROXY_INTERNAL_ACCOUNT_LABEL, PROXY_INTERNAL_ACCOUNT_TYPE, {
+        const attempt = metadata.lastUpstreamAttempt;
+        recordFinalError(status, attempt?.account ?? PROXY_INTERNAL_ACCOUNT_LABEL, attempt?.accountType ?? PROXY_INTERNAL_ACCOUNT_TYPE, {
             requestId: metadata.requestId,
             errorType,
             errorCode: options?.errorCode,
@@ -1322,8 +1325,13 @@ export async function createProxyStartApp(params) {
                 model: metadata.model,
                 stream: metadata.stream,
                 toolCount: metadata.toolCount,
-                account: "",
-                accountType: "proxy-runtime",
+                account: attempt?.account ?? "",
+                accountType: attempt?.accountType ?? "proxy-runtime",
+                accountKey: attempt?.accountKey,
+                provider: attempt?.provider,
+                transportScope: attempt?.transportScope,
+                traceId: attempt?.traceId,
+                spanId: attempt?.spanId,
                 responseStatus: status,
                 responseTimeMs: Date.now() - metadata.startedAt,
                 errorType,

package/dist/proxy/bodyCaptureProcessing.d.ts

@@ -9,6 +9,7 @@ export declare function prepareProxyBodyForLogging(body: unknown): {
     value?: string;
     bytes?: number;
     truncated: boolean;
+    originalBytes?: number;
 };
 /**
  * Expose the same header-redaction policy to replay and metadata

package/dist/proxy/bodyCaptureProcessing.js

@@ -6,6 +6,7 @@ import { gzip as gzipCallback } from "node:zlib";
 const REQUEST_LOG_IO_TIMEOUT_MS = 5_000;
 /** Maximum redacted body bytes persisted per capture entry. */
 const MAX_CAPTURED_BODY_BYTES = 1024 * 1024;
+const MAX_OTEL_CAPTURED_BODY_BYTES = 8 * 1024 * 1024;
 const BODY_TRUNCATION_MARKER = "\n...[TRUNCATED]";
 const gzip = promisify(gzipCallback);
 /** Headers whose values must always be redacted. */
@@ -130,12 +131,15 @@ export function splitUtf8StringByBytes(input, maxBytes) {
  * Apply structural redaction before enforcing the per-artifact byte
  * ceiling.
  */
-function prepareRedactedBody(body) {
+function prepareRedactedBody(body, maxBytes = MAX_CAPTURED_BODY_BYTES) {
     const redacted = redactBody(body);
     if (redacted === undefined) {
         return { truncated: false };
     }
-    return truncateUtf8String(redacted, MAX_CAPTURED_BODY_BYTES);
+    return {
+        ...truncateUtf8String(redacted, maxBytes),
+        originalBytes: utf8ByteLength(redacted),
+    };
 }
 /**
  * Write a private gzip artifact with a unique name and return its
@@ -202,7 +206,8 @@ export function redactProxyHeadersForLogging(headers) {
  */
 export async function processProxyBodyCapture(entry, logDir) {
     const headers = redactHeaders(entry.headers);
-    const prepared = prepareRedactedBody(entry.body);
+    const limit = logDir === null ? MAX_OTEL_CAPTURED_BODY_BYTES : MAX_CAPTURED_BODY_BYTES;
+    const prepared = prepareRedactedBody(entry.body, limit);
     if (logDir === null) {
         return {
             headers,
@@ -210,6 +215,9 @@ export async function processProxyBodyCapture(entry, logDir) {
                 redactedBody: prepared.value,
                 redactedBodyBytes: prepared.bytes,
                 bodyTruncated: prepared.truncated,
+                bodyCaptureLimitBytes: limit,
+                originalRedactedBodyBytes: prepared.originalBytes,
+                bodySha256: prepared.value === undefined ? undefined : sha256(prepared.value),
             },
         };
     }
@@ -225,5 +233,12 @@ export async function processProxyBodyCapture(entry, logDir) {
             bodyWriteFailed: true,
         };
     }
-    return { headers, stored };
+    return {
+        headers,
+        stored: {
+            ...stored,
+            bodyCaptureLimitBytes: limit,
+            originalRedactedBodyBytes: prepared.originalBytes,
+        },
+    };
 }

package/dist/proxy/bodyCaptureWorker.js

@@ -1,7 +1,9 @@
 import { Worker } from "node:worker_threads";
 const MAX_PENDING = 16;
 const MAX_PENDING_BYTES = 32 * 1024 * 1024;
-const MAX_ENTRY_BYTES = 8 * 1024 * 1024;
+// Bound retained UTF-16 strings rather than a 3x UTF-8 guess. This accommodates
+// the observed 7.3 MB JSON requests while retaining a 32 MiB aggregate pool.
+const MAX_ENTRY_BYTES = 16 * 1024 * 1024;
 export const PROXY_BODY_CAPTURE_DEADLINE_MS = 20_000;
 let worker;
 let workerUrl;
@@ -16,6 +18,7 @@ const snapshot = {
     pendingBytes: 0,
     maxPending: MAX_PENDING,
     maxPendingBytes: MAX_PENDING_BYTES,
+    rejectionReasons: {},
 };
 const pending = new Map();
 // Bound traversal as well as the structured clone sent to the worker. Never
@@ -29,12 +32,15 @@ function estimateCloneBytes(value) {
     const seen = new Set();
     let bytes = 0, nodes = 0;
     while (stack.length) {
-        if (++nodes > 100_000 || bytes > MAX_ENTRY_BYTES) {
-            return Infinity;
+        if (++nodes > 100_000) {
+            throw new Error("body_capture_traversal_limit");
+        }
+        if (bytes > MAX_ENTRY_BYTES) {
+            throw new Error("body_capture_entry_too_large");
         }
         const item = stack.pop();
         if (typeof item === "string") {
-            bytes += item.length * 3;
+            bytes += 16 + item.length * 2;
             continue;
         }
         bytes += 16;
@@ -42,23 +48,26 @@ function estimateCloneBytes(value) {
             continue;
         }
         if (seen.has(item)) {
-            return Infinity;
+            throw new Error("body_capture_unsupported_value");
         }
         seen.add(item);
         if (!Array.isArray(item) &&
             Object.getPrototypeOf(item) !== Object.prototype &&
             Object.getPrototypeOf(item) !== null) {
-            return Infinity;
+            throw new Error("body_capture_unsupported_value");
         }
         for (const key of Object.keys(item)) {
-            bytes += key.length * 3;
+            bytes += 16 + key.length * 2;
             const descriptor = Object.getOwnPropertyDescriptor(item, key);
             if (!descriptor || descriptor.get || descriptor.set) {
-                return Infinity;
+                throw new Error("body_capture_unsupported_value");
             }
             stack.push(descriptor.value);
-            if (stack.length > 100_000 || bytes > MAX_ENTRY_BYTES) {
-                return Infinity;
+            if (stack.length > 100_000) {
+                throw new Error("body_capture_traversal_limit");
+            }
+            if (bytes > MAX_ENTRY_BYTES) {
+                throw new Error("body_capture_entry_too_large");
             }
         }
     }
@@ -125,11 +134,21 @@ function getWorker() {
 export async function captureProxyBody(entry, logDir, consume) {
     snapshot.attempted += 1;
     let bytes;
+    let admissionError;
     try {
         bytes = estimateCloneBytes(entry);
     }
-    catch {
+    catch (error) {
         bytes = Infinity;
+        admissionError =
+            error instanceof Error &&
+                [
+                    "body_capture_entry_too_large",
+                    "body_capture_traversal_limit",
+                    "body_capture_unsupported_value",
+                ].includes(error.message)
+                ? error.message
+                : "body_capture_unsupported_value";
     }
     if (bytes > MAX_ENTRY_BYTES ||
         snapshot.pending >= MAX_PENDING ||
@@ -137,11 +156,13 @@ export async function captureProxyBody(entry, logDir, consume) {
         Date.now() < retryAfter) {
         snapshot.rejected += 1;
         const error = bytes > MAX_ENTRY_BYTES
-            ? "body_capture_too_large_or_non_json"
+            ? (admissionError ?? "body_capture_entry_too_large")
             : Date.now() < retryAfter
                 ? "body_worker_backoff"
                 : "body_capture_queue_full";
         snapshot.lastError = error;
+        snapshot.rejectionReasons[error] =
+            (snapshot.rejectionReasons[error] ?? 0) + 1;
         return consume({ error, stored: { bodyWriteFailed: true } });
     }
     let current;
@@ -204,7 +225,7 @@ export async function captureProxyBody(entry, logDir, consume) {
  * retained publication work.
  */
 export function getBodyCaptureWorkerSnapshot() {
-    return { ...snapshot };
+    return { ...snapshot, rejectionReasons: { ...snapshot.rejectionReasons } };
 }
 /** Isolated tests point at a separately executed built worker. */
 export const __bodyCaptureWorkerTestHooks = {
@@ -227,6 +248,7 @@ export const __bodyCaptureWorkerTestHooks = {
             pending: 0,
             pendingBytes: 0,
             lastError: undefined,
+            rejectionReasons: {},
         });
     },
 };

package/dist/proxy/otelLogSink.d.ts

@@ -1,6 +1,13 @@
 import { LoggerProvider } from "@opentelemetry/sdk-logs";
+import type { ProxyBodyChunkEmitter, ProxyBodyDeliveryResult } from "../types/index.js";
 /** Explicit opt-in; configuration never silently falls back to file logging. */
 export declare function isProxyOtelOnly(): boolean;
+/**
+ * Own a whole capture within byte/count bounds, then pace its chunks by actual
+ * export callbacks. SDK forceFlush alone does not await an automatic export
+ * already in flight. Serial publication prevents bursts from dropping tails.
+ */
+export declare function publishProxyOtelBody(captureId: string, body: string, emit: ProxyBodyChunkEmitter): Promise<ProxyBodyDeliveryResult>;
 /** Initialize a log-only provider in every proxy process, including the supervisor. */
 export declare function initializeProxyOtelLogs(role?: string): LoggerProvider | undefined;
 /** Structured evidence without final-request dashboard fields on auxiliary events. */
@@ -13,6 +20,19 @@ export declare function getProxyOtelLogSnapshot(): {
     initialized: boolean;
     deliveryGuarantee: string;
     invalidRecords: number;
+    bodyDelivery: {
+        attempted: number;
+        transportAcknowledged: number;
+        exportUnconfirmed: number;
+        rejected: number;
+        partial: number;
+        pending: number;
+        pendingBytes: number;
+        highWaterPending: number;
+        highWaterBytes: number;
+        maxPending: number;
+        maxPendingBytes: number;
+    };
     queues: {
         attempted: number;
         submitted: number;
@@ -22,7 +42,8 @@ export declare function getProxyOtelLogSnapshot(): {
         outstanding: number;
         lastAcknowledgedAt: string | undefined;
         lastFailureAt: string | undefined;
-        kind: string;
+        highWaterOutstanding: number;
+        kind: "metadata" | "bodies";
         capacity: number;
     }[];
 };

package/dist/proxy/otelLogSink.js

@@ -1,20 +1,40 @@
 /* eslint-disable no-console -- This proxy-only sink replaces console methods with OTLP emission. */
 import { inspect } from "node:util";
+import { setImmediate as yieldToRequests } from "node:timers/promises";
 import { SeverityNumber } from "@opentelemetry/api-logs";
 import { ExportResultCode } from "@opentelemetry/core";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { BatchLogRecordProcessor, LoggerProvider, } from "@opentelemetry/sdk-logs";
 import { sanitizeForLog } from "../utils/logSanitize.js";
+import { splitUtf8StringByBytes } from "./bodyCaptureProcessing.js";
 let provider;
 let restoreConsole;
 const queues = [];
+const bodyPublications = new Map();
+let bodyPublicationChain = Promise.resolve();
+let shuttingDown = false;
+const bodyDelivery = {
+    attempted: 0,
+    transportAcknowledged: 0,
+    exportUnconfirmed: 0,
+    rejected: 0,
+    partial: 0,
+    pending: 0,
+    pendingBytes: 0,
+    highWaterPending: 0,
+    highWaterBytes: 0,
+    maxPending: 16,
+    maxPendingBytes: 32 * 1024 * 1024,
+};
 /** Explicit opt-in; configuration never silently falls back to file logging. */
 export function isProxyOtelOnly() {
     return process.env.NEUROLINK_PROXY_LOG_SINK === "otel";
 }
 /** Reserve capacity including exports in flight, independently for metadata and bodies. */
-function createTrackedProcessor(url, capacity) {
+function createTrackedProcessor(url, capacity, kind) {
+    const unsettled = new Set();
+    const flushWaiters = new Set();
     const state = {
         attempted: 0,
         submitted: 0,
@@ -24,16 +44,23 @@ function createTrackedProcessor(url, capacity) {
         outstanding: 0,
         lastAcknowledgedAt: undefined,
         lastFailureAt: undefined,
+        highWaterOutstanding: 0,
     };
     const transport = new OTLPLogExporter({ url, timeoutMillis: 5000 });
     const exporter = {
         export(records, callback) {
             let settled = false;
+            const deadline = setTimeout(() => settle({
+                code: ExportResultCode.FAILED,
+                error: new Error("OTLP export callback deadline exceeded"),
+            }), 6_000);
+            deadline.unref();
             const settle = (result) => {
                 if (settled) {
                     return;
                 }
                 settled = true;
+                clearTimeout(deadline);
                 state.outstanding -= records.length;
                 if (result.code === ExportResultCode.SUCCESS) {
                     state.transportAcknowledged += records.length;
@@ -43,6 +70,23 @@ function createTrackedProcessor(url, capacity) {
                     state.exportUnconfirmed += records.length;
                     state.lastFailureAt = new Date().toISOString();
                 }
+                for (const record of records) {
+                    unsettled.delete(record);
+                    const id = record.attributes?.["body.capture_id"];
+                    const publication = typeof id === "string" ? bodyPublications.get(id) : undefined;
+                    if (publication) {
+                        if (result.code === ExportResultCode.SUCCESS) {
+                            publication.acknowledged++;
+                        }
+                        else {
+                            publication.unconfirmed++;
+                        }
+                        publication.notify?.();
+                    }
+                }
+                for (const notify of flushWaiters) {
+                    notify();
+                }
                 callback(result);
             };
             try {
@@ -66,18 +110,193 @@ function createTrackedProcessor(url, capacity) {
     const processor = {
         onEmit(record) {
             state.attempted++;
+            const id = record.attributes?.["body.capture_id"];
+            const publication = typeof id === "string" ? bodyPublications.get(id) : undefined;
+            if (publication) {
+                publication.emitted++;
+            }
             if (state.outstanding >= capacity) {
                 state.dropped++;
+                if (publication) {
+                    publication.dropped++;
+                    publication.notify?.();
+                }
                 return;
             }
             state.submitted++;
             state.outstanding++;
+            unsettled.add(record);
+            state.highWaterOutstanding = Math.max(state.highWaterOutstanding, state.outstanding);
             batch.onEmit(record);
         },
-        forceFlush: () => batch.forceFlush(),
-        shutdown: () => batch.shutdown(),
+        forceFlush: async () => {
+            const boundary = new Set(unsettled);
+            try {
+                await batch.forceFlush();
+            }
+            finally {
+                await new Promise((resolve) => {
+                    const check = () => {
+                        if (![...boundary].some((record) => unsettled.has(record))) {
+                            flushWaiters.delete(check);
+                            resolve();
+                        }
+                    };
+                    flushWaiters.add(check);
+                    check();
+                });
+            }
+        },
+        shutdown: async () => {
+            try {
+                await processor.forceFlush();
+            }
+            finally {
+                await batch.shutdown();
+            }
+        },
     };
-    return { state, processor, capacity };
+    return { state, processor, capacity, kind };
+}
+/**
+ * Own a whole capture within byte/count bounds, then pace its chunks by actual
+ * export callbacks. SDK forceFlush alone does not await an automatic export
+ * already in flight. Serial publication prevents bursts from dropping tails.
+ */
+export async function publishProxyOtelBody(captureId, body, emit) {
+    bodyDelivery.attempted++;
+    const bytes = Buffer.byteLength(body, "utf8");
+    if (!provider ||
+        shuttingDown ||
+        bodyPublications.has(captureId) ||
+        bodyDelivery.pending >= bodyDelivery.maxPending ||
+        bodyDelivery.pendingBytes + bytes > bodyDelivery.maxPendingBytes) {
+        bodyDelivery.rejected++;
+        return {
+            status: "rejected",
+            acknowledgedChunks: 0,
+            unconfirmedChunks: 0,
+            droppedChunks: 0,
+            reason: bodyPublications.has(captureId)
+                ? "body_capture_id_in_use"
+                : !provider || shuttingDown
+                    ? "body_exporter_unavailable"
+                    : "body_publication_queue_full",
+        };
+    }
+    bodyDelivery.pending++;
+    bodyDelivery.pendingBytes += bytes;
+    bodyDelivery.highWaterPending = Math.max(bodyDelivery.highWaterPending, bodyDelivery.pending);
+    bodyDelivery.highWaterBytes = Math.max(bodyDelivery.highWaterBytes, bodyDelivery.pendingBytes);
+    const progress = {
+        acknowledged: 0,
+        unconfirmed: 0,
+        dropped: 0,
+        emitted: 0,
+    };
+    bodyPublications.set(captureId, progress);
+    const deadline = Date.now() + 20_000;
+    const operation = bodyPublicationChain.then(async () => {
+        const queue = queues.find((candidate) => candidate.kind === "bodies");
+        if (!queue || Date.now() >= deadline) {
+            return {
+                status: "rejected",
+                acknowledgedChunks: 0,
+                unconfirmedChunks: 0,
+                droppedChunks: 0,
+                reason: !queue
+                    ? "body_exporter_unavailable"
+                    : "body_publication_deadline",
+            };
+        }
+        const chunks = splitUtf8StringByBytes(body, 16_000);
+        const awaitSettlement = () => new Promise((resolve) => {
+            const check = () => {
+                if (progress.acknowledged + progress.unconfirmed + progress.dropped >=
+                    progress.emitted) {
+                    progress.notify = undefined;
+                    resolve();
+                }
+            };
+            progress.notify = check;
+            check();
+        });
+        let reason;
+        try {
+            for (let offset = 0; offset < chunks.length; offset += 64) {
+                if (Date.now() >= deadline) {
+                    reason = "body_publication_deadline";
+                    break;
+                }
+                // Ordinary body records from an external logger may share this queue.
+                // Wait for them before admitting any part of this batch.
+                while (queue.state.outstanding > queue.capacity - 64) {
+                    await queue.processor.forceFlush();
+                    if (Date.now() >= deadline) {
+                        throw new Error("body_publication_deadline");
+                    }
+                }
+                for (let i = offset; i < Math.min(offset + 64, chunks.length); i++) {
+                    emit(chunks[i], i, chunks.length);
+                }
+                await queue.processor.forceFlush();
+                await awaitSettlement();
+                if (progress.unconfirmed || progress.dropped) {
+                    reason = "body_export_unconfirmed";
+                    break;
+                }
+                await yieldToRequests();
+            }
+        }
+        catch (error) {
+            reason =
+                error instanceof Error &&
+                    error.message === "body_publication_deadline"
+                    ? "body_publication_deadline"
+                    : "body_publication_failed";
+            // Retain ownership of already submitted chunks until their callbacks settle.
+            await queue.processor.forceFlush().catch(() => undefined);
+            await awaitSettlement();
+        }
+        const status = progress.emitted === 0 && chunks.length > 0
+            ? "rejected"
+            : progress.dropped || progress.emitted !== chunks.length
+                ? "partial"
+                : progress.unconfirmed
+                    ? "export_unconfirmed"
+                    : "transport_acknowledged";
+        return {
+            status,
+            expectedChunks: chunks.length,
+            acknowledgedChunks: progress.acknowledged,
+            unconfirmedChunks: progress.unconfirmed,
+            droppedChunks: progress.dropped,
+            notSubmittedChunks: chunks.length - progress.emitted,
+            ...(reason ? { reason } : {}),
+        };
+    });
+    bodyPublicationChain = operation.then(() => undefined, () => undefined);
+    try {
+        const result = await operation;
+        if (result.status === "transport_acknowledged") {
+            bodyDelivery.transportAcknowledged++;
+        }
+        else if (result.status === "export_unconfirmed") {
+            bodyDelivery.exportUnconfirmed++;
+        }
+        else if (result.status === "rejected") {
+            bodyDelivery.rejected++;
+        }
+        else {
+            bodyDelivery.partial++;
+        }
+        return result;
+    }
+    finally {
+        bodyPublications.delete(captureId);
+        bodyDelivery.pending--;
+        bodyDelivery.pendingBytes -= bytes;
+    }
 }
 /** Initialize a log-only provider in every proxy process, including the supervisor. */
 export function initializeProxyOtelLogs(role = "worker") {
@@ -102,8 +321,8 @@ export function initializeProxyOtelLogs(role = "worker") {
     if (url.protocol === "http:" && !loopback) {
         throw new Error("Proxy OTLP logs require HTTPS for non-loopback collectors");
     }
-    const metadata = createTrackedProcessor(endpoint, 2048);
-    const bodies = createTrackedProcessor(endpoint, 256);
+    const metadata = createTrackedProcessor(endpoint, 2048, "metadata");
+    const bodies = createTrackedProcessor(endpoint, 256, "bodies");
     queues.push(metadata, bodies);
     provider = new LoggerProvider({
         resource: resourceFromAttributes({
@@ -220,8 +439,9 @@ export function getProxyOtelLogSnapshot() {
         initialized: provider !== undefined,
         deliveryGuarantee: "best-effort; HTTP success is not per-record acceptance or backend persistence",
         invalidRecords,
-        queues: queues.map((q, index) => ({
-            kind: index === 0 ? "metadata" : "bodies",
+        bodyDelivery: { ...bodyDelivery },
+        queues: queues.map((q) => ({
+            kind: q.kind,
             capacity: q.capacity,
             ...q.state,
         })),
@@ -229,16 +449,35 @@ export function getProxyOtelLogSnapshot() {
 }
 /** Bounded provider flush belongs after final request and lifecycle publication. */
 export async function flushProxyOtelLogs() {
+    await bodyPublicationChain;
     await provider?.forceFlush();
 }
 /** Release this process's exporter and restore console ownership. */
 export async function shutdownProxyOtelLogs() {
+    shuttingDown = true;
+    await bodyPublicationChain;
     restoreConsole?.();
     restoreConsole = undefined;
     await provider?.shutdown();
     provider = undefined;
     queues.length = 0;
     invalidRecords = 0;
+    bodyPublications.clear();
+    bodyPublicationChain = Promise.resolve();
+    shuttingDown = false;
+    for (const key of [
+        "attempted",
+        "transportAcknowledged",
+        "exportUnconfirmed",
+        "rejected",
+        "partial",
+        "pending",
+        "pendingBytes",
+        "highWaterPending",
+        "highWaterBytes",
+    ]) {
+        bodyDelivery[key] = 0;
+    }
 }
 /** Flush short-lived proxy command diagnostics on every normal return or exception. */
 export function withProxyOtelLogShutdown(handler) {

package/dist/proxy/proxyActivity.d.ts

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

package/dist/proxy/proxyActivity.js

@@ -9,18 +9,37 @@ let lastActivityAtMs = null;
 // where bytes actually leave the proxy.
 const responseObserversByMetadata = new WeakMap();
 const finalLogObservers = new Map();
+const attemptLogObservers = new Map();
 /** Join route accounting to the HTTP lifecycle without relying on write order. */
-export function observeProxyFinalLog(requestId, observer) {
+export function observeProxyFinalLog(requestId, observer, attemptObserver) {
     finalLogObservers.set(requestId, observer);
+    if (attemptObserver) {
+        attemptLogObservers.set(requestId, attemptObserver);
+    }
+    else {
+        attemptLogObservers.delete(requestId);
+    }
     return () => {
         if (finalLogObservers.get(requestId) === observer) {
             finalLogObservers.delete(requestId);
+            attemptLogObservers.delete(requestId);
         }
     };
 }
 export function notifyProxyFinalLog(entry) {
     finalLogObservers.get(entry.requestId)?.(entry);
 }
+/** Retain only the last attempt for a currently observed HTTP request. */
+export function notifyProxyAttemptLog(entry) {
+    const observer = attemptLogObservers.get(entry.requestId);
+    observer?.(entry);
+    if (entry.parentRequestId && entry.parentRequestId !== entry.requestId) {
+        const parentObserver = attemptLogObservers.get(entry.parentRequestId);
+        if (parentObserver !== observer) {
+            parentObserver?.(entry);
+        }
+    }
+}
 export function registerProxyResponseObserver(metadata, observer) {
     const existing = responseObserversByMetadata.get(metadata);
     if (existing) {

package/dist/proxy/requestLogger.d.ts

@@ -33,6 +33,7 @@ export declare function prepareProxyBodyForLogging(body: unknown): {
     value?: string;
     bytes?: number;
     truncated: boolean;
+    originalBytes?: number;
 };
 /** Capture an owned request body with bounded processing and tracked index/export publication. */
 export declare function logBodyCapture(entry: ProxyBodyCaptureEntry): Promise<void>;