@juspay/neurolink 12.12.6 → 12.12.8

package/dist/cli/commands/proxy.js

@@ -26,7 +26,7 @@ import { ProxyRuntimeConfigStore } from "../../proxy/runtimeConfig.js";
 import { startProxyLogCleanupScheduler } from "../../proxy/logCleanupScheduler.js";
 import { anthropicAccountKeysEqual, createAccountAllowlist, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, normalizeAnthropicAccountKey, shouldLoadFallbackCredential, } from "../../proxy/accountSelection.js";
 import { resolveProxyStatusAccountIdentity } from "../../proxy/codexAccountUsage.js";
-import { beginProxyRequest, getProxyActivitySnapshot, takeProxyResponseObservers, trackProxyResponse, } from "../../proxy/proxyActivity.js";
+import { beginProxyRequest, getProxyActivitySnapshot, observeProxyFinalLog, takeProxyResponseObservers, trackProxyResponse, } from "../../proxy/proxyActivity.js";
 import { flushProxyLifecycleEvents, getProxyLifecycleLoggerSnapshot, hashProxyLifecycleSessionId, logProxyLifecycleEvent, } from "../../proxy/proxyLifecycle.js";
 import { describeInstallFailure, getGlobalInstallArgs, isTransientInstallFailure, resolveGlobalInstaller, validateInstalledVersion, } from "../../proxy/globalInstaller.js";
 import { startUpdaterWorkerSupervisor } from "../../proxy/updaterSupervisor.js";
@@ -1079,10 +1079,14 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
             rejectForUpdate: readiness.drainingForUpdate,
         };
         requestMetadata.set(c.req.raw, metadata);
+        const stopObservingFinalLog = observeProxyFinalLog(metadata.requestId, (entry) => {
+            metadata.terminalResult = entry;
+        });
         const finishActivity = metadata.rejectForUpdate
             ? () => undefined
             : beginProxyRequest();
         const finish = () => {
+            stopObservingFinalLog();
             finishActivity();
             // Borrowed traffic holds a concurrency slot for the lifetime of the
             // response body, so it is released here rather than when the handler
@@ -1130,15 +1134,9 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                     }
                 }
             };
-            const notifyRouteTerminal = (details) => {
-                for (const observer of routeResponseObservers) {
-                    try {
-                        observer.onTerminal?.(details);
-                    }
-                    catch {
-                        // Route-level accounting must never interfere with the relay.
-                    }
-                }
+            const notifyRouteTerminal = async (details) => {
+                const results = await withTimeout(Promise.allSettled(routeResponseObservers.map(async (observer) => observer.onTerminal?.(details))), 2_000, "Timed out joining proxy response accounting");
+                return results.some((result) => result.status === "rejected");
             };
             c.res = trackProxyResponse(c.res, finish, {
                 onFirstChunk: ({ observedBodyBytes, responseChunks }) => {
@@ -1162,13 +1160,39 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                         responseChunks,
                     });
                 },
-                onTerminal: ({ outcome, observedBodyBytes, responseChunks }) => {
-                    if (outcome === "completed" &&
-                        metadata.terminalErrorType === "stream_error") {
-                        outcome = "stream_error";
+                onTerminal: async ({ outcome, error, observedBodyBytes, responseChunks, }) => {
+                    const terminalMonotonicMs = performance.now();
+                    const terminalTimestampMs = Date.now();
+                    // Route accounting may await SSE parsing/cancellation. Join it before
+                    // publishing the semantic terminal record; transport EOF alone is not
+                    // evidence of a successful model response.
+                    let accountingTimedOut = false;
+                    let accountingFailed = false;
+                    try {
+                        accountingFailed = await notifyRouteTerminal({
+                            outcome,
+                            error,
+                            observedBodyBytes,
+                            responseChunks,
+                        });
+                    }
+                    catch {
+                        accountingTimedOut = true;
                     }
+                    const final = metadata.terminalResult;
+                    const terminalOutcome = final?.terminalOutcome ??
+                        (outcome === "stream_error" ||
+                            metadata.terminalErrorType === "stream_error"
+                            ? "stream_error"
+                            : outcome === "client_cancelled"
+                                ? "client_cancelled"
+                                : responseStatus >= 400
+                                    ? "handler_error"
+                                    : "unknown");
                     logProxyLifecycleEvent({
                         event: "request_terminal",
+                        timestampMs: terminalTimestampMs,
+                        monotonicMs: terminalMonotonicMs,
                         requestId: metadata.requestId,
                         method: metadata.method,
                         path: metadata.path,
@@ -1180,20 +1204,33 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                         responseStatus,
                         observedBodyBytes,
                         responseChunks,
-                        elapsedMs: performance.now() - startedMonotonicMs,
-                        terminalOutcome: outcome,
-                        errorType: metadata.terminalErrorType,
-                        errorCode: metadata.terminalErrorCode,
-                    });
-                    notifyRouteTerminal({
-                        outcome,
-                        observedBodyBytes,
-                        responseChunks,
+                        elapsedMs: terminalMonotonicMs - startedMonotonicMs,
+                        terminalOutcome,
+                        finalStatus: final?.responseStatus,
+                        transportOutcome: outcome,
+                        outcomeSource: final
+                            ? "final_request"
+                            : responseStatus >= 400
+                                ? "http_status"
+                                : terminalOutcome === "unknown"
+                                    ? "unknown"
+                                    : "transport_error",
+                        telemetryStatus: accountingTimedOut
+                            ? "timeout"
+                            : accountingFailed
+                                ? "observer_error"
+                                : final
+                                    ? "complete"
+                                    : "missing_final",
+                        errorType: final?.errorType ?? metadata.terminalErrorType,
+                        errorCode: final?.errorCode ?? metadata.terminalErrorCode,
                     });
+                    stopObservingFinalLog();
                 },
             });
         }
         catch (error) {
+            stopObservingFinalLog();
             // Keep metadata available to app.onError, which records the client-facing
             // failure with the same request ID before deleting the WeakMap entry.
             finishActivity();
@@ -1238,7 +1275,7 @@ export async function createProxyStartApp(params) {
     const { createOpenAIProxyRoutes } = await import("../../server/routes/openaiProxyRoutes.js");
     const { createCodexProxyRoutes } = await import("../../server/routes/codexProxyRoutes.js");
     const { createGeminiProxyRoutes } = await import("../../server/routes/geminiProxyRoutes.js");
-    const { logBodyCapture, logRequest } = await import("../../proxy/requestLogger.js");
+    const { logBodyCapture, logRequest, getRequestLoggerSnapshot } = await import("../../proxy/requestLogger.js");
     const { recordFinalError } = await import("../../proxy/usageStats.js");
     const { admitInboundShareRequest, isGrantRequiredByEnv } = await import("../../proxy/shareGate.js");
     const { runWithShareContext } = await import("../../proxy/shareContext.js");
@@ -1978,6 +2015,7 @@ export async function createProxyStartApp(params) {
             })(),
             observability: {
                 lifecycle: getProxyLifecycleLoggerSnapshot(),
+                requestLogs: getRequestLoggerSnapshot(),
             },
             autoUpdate: {
                 enabled: isProxyAutoUpdateEnabled(),

package/dist/cli/commands/proxyAnalyze.js

@@ -70,6 +70,7 @@ function printAnalysis(report) {
     for (const [label, summary] of [
         ["Response headers", report.latencyMs.headers],
         ["First chunk", report.latencyMs.firstChunk],
+        ["First useful output", report.latencyMs.firstUsefulOutput],
         ["Terminal", report.latencyMs.terminal],
         ["Final request log", report.latencyMs.finalRequest],
         ["Account attempt", report.latencyMs.attempt],
@@ -100,7 +101,9 @@ function printAnalysis(report) {
     if (!report.coverage.comparableRequestAttempts) {
         logger.always(chalk.yellow("    WARNING: request and attempt totals do not cover a comparable full window; do not reconcile them as one cohort"));
     }
-    logger.always(`    ${report.dataQuality.linesRead} lines scanned, ${report.dataQuality.malformedLines} malformed, ${report.dataQuality.unsupportedLifecycleLines} unsupported lifecycle, ${report.dataQuality.lifecycleSequenceGaps} sequence gaps, ${report.dataQuality.lifecycleSequenceDuplicates} duplicates`);
+    logger.always(`    ${report.dataQuality.linesRead} lines scanned, ${report.dataQuality.malformedLines} malformed, ${report.dataQuality.unsupportedLifecycleLines} unsupported lifecycle, ${report.dataQuality.lifecycleSequenceGaps} sequence gaps, ${report.dataQuality.lifecycleSequenceDuplicates} duplicates (${report.dataQuality.conflictingLifecycleDuplicates} conflicting)`);
+    logger.always(`    Outcome evidence: ${report.dataQuality.finalOutcomeConflicts} conflicts reconciled, ${report.dataQuality.acceptedWithoutFinal} accepted without a final record, ${report.dataQuality.terminalWithoutFinal} transport terminals without a final record`);
+    logger.always(`    Repeated attempt records merged: ${report.dataQuality.duplicateAttempts}`);
     logger.always(`    Routing decisions: ${report.dataQuality.routingDecisions.valid} valid, ${report.dataQuality.routingDecisions.invalid} invalid, ${report.dataQuality.routingDecisions.absent} absent`);
     for (const [stream, range] of Object.entries(report.dataQuality.streams)) {
         if (range.observedFrom) {

package/dist/core/toolExecutionRecorder.d.ts

@@ -9,7 +9,7 @@
  * params, timing, and error status. Memory is bounded: serialized results are
  * capped at `maxResultChars` and the record list at `maxRecords`.
  */
-import type { Tool, ToolExecutionCaptureOptions, ToolExecutionRecord } from "../types/index.js";
+import type { Tool, ToolExecutionCaptureOptions, ToolExecutionRecord, StandardRecord, ToolExecutionSummaryInternal } from "../types/index.js";
 /** Default cap on serialized result characters kept per record (~8KB). */
 export declare const DEFAULT_TOOL_RESULT_CAPTURE_CHARS = 8192;
 /** Default cap on records kept per turn. */
@@ -73,4 +73,19 @@ export declare function toToolExecutionRecords(legacyExecutions: unknown[] | und
  * carried a recorder that saw executions, else a conversion of the loop's
  * legacy accumulator entries.
  */
+/**
+ * The public `toolCalls` view of a native turn's execution summaries.
+ *
+ * The native generate loops record every executed call in
+ * `ToolExecutionSummaryInternal[]` and surface it as `toolExecutions`, but
+ * never mapped it onto `EnhancedGenerateResult.toolCalls` — the field the type
+ * has always declared and the ai-package formatter used to fill. A caller
+ * reading `result.toolCalls` after a tool ran saw nothing. This is the one
+ * place that mapping lives, so the three native paths cannot drift apart.
+ */
+export declare function toolCallsFromSummaries(summaries: ReadonlyArray<ToolExecutionSummaryInternal>): Array<{
+    toolCallId: string;
+    toolName: string;
+    args: StandardRecord;
+}>;
 export declare function resolveToolExecutionRecords(options: unknown, legacyExecutions?: unknown[]): ToolExecutionRecord[];

package/dist/core/toolExecutionRecorder.js

@@ -247,6 +247,27 @@ export function toToolExecutionRecords(legacyExecutions, capture) {
  * carried a recorder that saw executions, else a conversion of the loop's
  * legacy accumulator entries.
  */
+/**
+ * The public `toolCalls` view of a native turn's execution summaries.
+ *
+ * The native generate loops record every executed call in
+ * `ToolExecutionSummaryInternal[]` and surface it as `toolExecutions`, but
+ * never mapped it onto `EnhancedGenerateResult.toolCalls` — the field the type
+ * has always declared and the ai-package formatter used to fill. A caller
+ * reading `result.toolCalls` after a tool ran saw nothing. This is the one
+ * place that mapping lives, so the three native paths cannot drift apart.
+ */
+export function toolCallsFromSummaries(summaries) {
+    return summaries.map((summary) => ({
+        toolCallId: summary.toolCallId,
+        toolName: summary.toolName,
+        args: summary.input !== null &&
+            typeof summary.input === "object" &&
+            !Array.isArray(summary.input)
+            ? summary.input
+            : {},
+    }));
+}
 export function resolveToolExecutionRecords(options, legacyExecutions) {
     const recorder = ToolExecutionRecorder.from(options);
     if (recorder?.hasRecords()) {

package/dist/middleware/builtin/guardrails.js

@@ -1,6 +1,45 @@
 import { createBlockedResponse, createBlockedStream, applyContentFiltering, handlePrecallGuardrails, } from "../utils/guardrailsUtils.js";
 import { logger } from "../../utils/logger.js";
 import { generateOnceNative } from "../../utils/nativeSingleShot.js";
+/**
+ * Filter each contiguous run of text parts as one string.
+ *
+ * A prohibited term that straddles two adjacent text parts is invisible to a
+ * per-part filter, and the parts are concatenated downstream (`lifecycle.ts`
+ * joins adjacent text), so the term reached the caller whole. Anthropic's
+ * native path emits one text part per content block, so adjacent parts are a
+ * real shape, not a theoretical one. Non-text parts keep their position; a run
+ * is rebuilt as a single text part only when the filter changed it.
+ */
+const filterTextRuns = (content, badWords, context) => {
+    const out = [];
+    let run = [];
+    const flushRun = () => {
+        if (run.length === 0) {
+            return;
+        }
+        const merged = run.map((part) => part.text).join("");
+        const filtered = applyContentFiltering(merged, badWords, context);
+        if (filtered.hasChanges) {
+            out.push({ ...run[0], text: filtered.filteredText });
+        }
+        else {
+            out.push(...run);
+        }
+        run = [];
+    };
+    for (const part of content) {
+        if (part.type === "text") {
+            run.push(part);
+        }
+        else {
+            flushRun();
+            out.push(part);
+        }
+    }
+    flushRun();
+    return out;
+};
 /**
  * Create Guardrails AI middleware for content filtering and policy enforcement
  * @param config Configuration for the guardrails middleware
@@ -61,12 +100,7 @@ export function createGuardrailsMiddleware(config = {}) {
             let result = await doGenerate();
             result = {
                 ...result,
-                content: result.content.map((part) => part.type === "text"
-                    ? {
-                        ...part,
-                        text: applyContentFiltering(part.text, config.badWords, "generate").filteredText,
-                    }
-                    : part),
+                content: filterTextRuns(result.content, config.badWords, "generate"),
             };
             if (config.modelFilter?.enabled && config.modelFilter.filterModel) {
                 logger.debug(`[GuardrailsMiddleware] Invoking model-based filter.`);
@@ -113,22 +147,38 @@ export function createGuardrailsMiddleware(config = {}) {
             }
             const { stream, ...rest } = await doStream();
             let hasYieldedChunks = false;
+            // With bad-word filtering on, a text run is buffered and filtered as one
+            // string: a term split across deltas is invisible per delta and every
+            // consumer reassembles it. The run is released when a non-text part
+            // arrives or the stream ends, so the guardrail trades incremental
+            // delivery of that run for not being bypassable by chunking. With
+            // filtering off, deltas pass through untouched and unbuffered.
+            const bufferTextRuns = config.badWords?.enabled === true;
+            let pendingText;
+            const releaseText = (controller) => {
+                if (!pendingText) {
+                    return;
+                }
+                const filtered = applyContentFiltering(pendingText.delta, config.badWords, "stream");
+                controller.enqueue(filtered.hasChanges
+                    ? { ...pendingText, delta: filtered.filteredText }
+                    : pendingText);
+                pendingText = undefined;
+            };
             const transformStream = new TransformStream({
                 transform(chunk, controller) {
                     hasYieldedChunks = true;
-                    let filteredChunk = chunk;
-                    if (filteredChunk.type === "text-delta") {
-                        const filterResult = applyContentFiltering(filteredChunk.delta, config.badWords, "stream");
-                        if (filterResult.hasChanges) {
-                            filteredChunk = {
-                                ...filteredChunk,
-                                delta: filterResult.filteredText,
-                            };
-                        }
+                    if (chunk.type === "text-delta" && bufferTextRuns) {
+                        pendingText = pendingText
+                            ? { ...pendingText, delta: pendingText.delta + chunk.delta }
+                            : chunk;
+                        return;
                     }
-                    controller.enqueue(filteredChunk);
+                    releaseText(controller);
+                    controller.enqueue(chunk);
                 },
-                flush() {
+                flush(controller) {
+                    releaseText(controller);
                     if (!hasYieldedChunks) {
                         logger.warn(`[GuardrailsMiddleware] Stream ended without yielding any chunks`);
                     }

package/dist/neurolink.js

@@ -4359,6 +4359,7 @@ Current user's request: ${currentInput}`;
                 : undefined,
             responseTime: textResult.responseTime,
             toolsUsed: textResult.toolsUsed,
+            toolCalls: textResult.toolCalls ?? [],
             toolExecutions: toToolExecutionRecords(textResult.toolExecutions),
             enhancedWithTools: textResult.enhancedWithTools,
             availableTools: transformAvailableTools(textResult.availableTools),
@@ -5877,6 +5878,7 @@ Current user's request: ${currentInput}`;
             rawFinishReason: result.rawFinishReason,
             stepsUsed: result.stepsUsed,
             toolsUsed: result.toolsUsed || [],
+            toolCalls: result.toolCalls ?? [],
             toolExecutions: transformedToolExecutions,
             enhancedWithTools: Boolean(hasToolExecutions),
             availableTools: transformToolsForMCP(transformToolsToExpectedFormat(availableTools)),
@@ -6028,6 +6030,7 @@ Current user's request: ${currentInput}`;
                         rawFinishReason: poolResult.rawFinishReason,
                         stepsUsed: poolResult.stepsUsed,
                         toolsUsed: poolResult.toolsUsed || [],
+                        toolCalls: poolResult.toolCalls ?? [],
                         // Lossless pass-through: keep the full ToolExecutionRecord
                         // fields (params/resultText/isError/timing) alongside the
                         // legacy {toolName,executionTime,success} shape this internal
@@ -6398,6 +6401,9 @@ Current user's request: ${currentInput}`;
                     rawFinishReason: result.rawFinishReason,
                     stepsUsed: result.stepsUsed,
                     toolsUsed: result.toolsUsed || [],
+                    // The providers record executed calls; without this line the public
+                    // result never carried them, whatever the provider returned.
+                    toolCalls: result.toolCalls ?? [],
                     // Lossless pass-through: keep the full ToolExecutionRecord fields
                     // alongside the legacy {toolName,executionTime,success} shape this
                     // internal result declares, so the final GenerateResult mapping

package/dist/providers/amazonSagemaker.js

@@ -2,7 +2,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { createStreamChannel } from "../core/streamChannel.js";
 import { logger } from "../utils/logger.js";
 import { resolveRequestKind } from "../core/resolveRequestKind.js";
-import { resolveToolExecutionRecords } from "../core/toolExecutionRecorder.js";
+import { resolveToolExecutionRecords, toolCallsFromSummaries, } from "../core/toolExecutionRecorder.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { withProviderRetry } from "../utils/providerRetry.js";
@@ -198,6 +198,7 @@ export class AmazonSageMakerProvider extends BaseProvider {
             },
             responseTime: Date.now() - startTime,
             toolsUsed: loop.toolsUsed,
+            toolCalls: toolCallsFromSummaries(toolExecutionSummaries),
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),
             enhancedWithTools: loop.toolsUsed.length > 0,
         };

package/dist/providers/anthropic/client.js

@@ -28,7 +28,7 @@ import { runAgenticLoop } from "../../core/loopEngine.js";
 import { hasNativeDoGenerate, runNativeGenerateLoop, } from "../../core/nativeGenerateLoop.js";
 import { withProviderRetry } from "../../utils/providerRetry.js";
 import { resolveRequestKind } from "../../core/resolveRequestKind.js";
-import { resolveToolExecutionRecords } from "../../core/toolExecutionRecorder.js";
+import { resolveToolExecutionRecords, toolCallsFromSummaries, } from "../../core/toolExecutionRecorder.js";
 import { transformToolExecutions } from "../../utils/transformationUtils.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../../utils/timeout.js";
@@ -1479,6 +1479,7 @@ export class AnthropicProvider extends BaseProvider {
             },
             responseTime: Date.now() - startTime,
             toolsUsed: loop.toolsUsed,
+            toolCalls: toolCallsFromSummaries(toolExecutionSummaries),
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),
             enhancedWithTools: loop.toolsUsed.length > 0,
         };

package/dist/providers/openaiChatCompletionsBase.js

@@ -34,7 +34,7 @@ import { composeAbortSignalsScoped, createTimeoutController, mergeAbortSignals,
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { resolveRequestKind } from "../core/resolveRequestKind.js";
 import { appendJsonSchemaInstruction, hasNativeDoGenerate, runNativeGenerateLoop, } from "../core/nativeGenerateLoop.js";
-import { resolveToolExecutionRecords } from "../core/toolExecutionRecorder.js";
+import { resolveToolExecutionRecords, toolCallsFromSummaries, } from "../core/toolExecutionRecorder.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { coerceJsonToSchema, schemaAccepts } from "../utils/json/coerce.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
@@ -989,6 +989,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             },
             responseTime: Date.now() - startTime,
             toolsUsed,
+            toolCalls: toolCallsFromSummaries(toolExecutionSummaries),
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),
             enhancedWithTools: toolsUsed.length > 0,
         };

package/dist/proxy/codexUsage.d.ts

@@ -39,7 +39,7 @@
  * `prompt_tokens`/`completion_tokens` spellings. A `null` result means "not
  * observed", never "zero tokens".
  */
-import type { CodexStreamUsage } from "../types/index.js";
+import type { CodexStreamUsage, CodexStreamEvidence } from "../types/index.js";
 /**
  * Pull usage out of one parsed SSE `data:` payload.
  *
@@ -65,4 +65,5 @@ export declare function scanCodexSSEForUsage(text: string): CodexStreamUsage | n
 export declare function createCodexUsageTap(): {
     stream: TransformStream<Uint8Array, Uint8Array>;
     usage: Promise<CodexStreamUsage | null>;
+    evidence: () => CodexStreamEvidence;
 };

package/dist/proxy/codexUsage.js

@@ -40,6 +40,8 @@
  * observed", never "zero tokens".
  */
 import { appendFileSync } from "node:fs";
+import { extractSSEEvents } from "./sseInterceptor.js";
+import { sanitizeForLog } from "../utils/logSanitize.js";
 const nonNegativeInt = (value) => typeof value === "number" && Number.isFinite(value) && value > 0
     ? Math.floor(value)
     : 0;
@@ -161,6 +163,68 @@ function createCaptureSink() {
  * none was. It never rejects.
  */
 export function createCodexUsageTap() {
+    const evidence = { completed: false, terminalBytes: 0 };
+    let totalBytes = 0;
+    const inspectEvidence = (events) => {
+        for (const frame of events) {
+            try {
+                const event = JSON.parse(frame.data);
+                if (!event || typeof event !== "object") {
+                    continue;
+                }
+                const seen = extractCodexUsage(event);
+                if (seen) {
+                    latest = seen;
+                }
+                const type = event.type ?? frame.event;
+                if ((type === "response.output_text.delta" ||
+                    type === "response.function_call_arguments.delta") &&
+                    typeof event.delta === "string" &&
+                    event.delta.length > 0) {
+                    evidence.firstUsefulOutputAt ??= Date.now();
+                }
+                if (type === "response.completed") {
+                    evidence.completed = true;
+                    evidence.terminalBytes = totalBytes;
+                }
+                else if (type === "error" ||
+                    type === "response.failed" ||
+                    type === "response.incomplete") {
+                    evidence.errorType = "stream_error";
+                    const response = event.response;
+                    const details = response && typeof response === "object"
+                        ? response
+                        : event;
+                    const rawError = details.error;
+                    const error = rawError && typeof rawError === "object"
+                        ? rawError
+                        : details;
+                    const incomplete = details.incomplete_details;
+                    const reason = incomplete &&
+                        typeof incomplete === "object" &&
+                        "reason" in incomplete
+                        ? incomplete.reason
+                        : undefined;
+                    evidence.errorCode =
+                        typeof error.code === "string"
+                            ? sanitizeForLog(error.code).slice(0, 200)
+                            : typeof reason === "string"
+                                ? sanitizeForLog(reason).slice(0, 200)
+                                : String(type);
+                    evidence.errorMessage =
+                        typeof error.message === "string"
+                            ? sanitizeForLog(error.message).slice(0, 200)
+                            : type === "response.incomplete"
+                                ? "Codex reported an incomplete response"
+                                : "Codex reported a stream failure";
+                    evidence.terminalBytes = totalBytes;
+                }
+            }
+            catch {
+                // Unknown frames cannot establish successful completion.
+            }
+        }
+    };
     let settleUsage = () => { };
     const usage = new Promise((resolve) => {
         settleUsage = resolve;
@@ -179,40 +243,33 @@ export function createCodexUsageTap() {
     const capture = createCaptureSink();
     let carry = "";
     let latest = null;
-    /**
-     * Ceiling on the unterminated tail we are willing to hold.
-     *
-     * `carry` normally holds a fraction of one SSE line, because every newline
-     * flushes it. A stream that never sends one — a hung upstream, a
-     * non-SSE body relayed by mistake — would otherwise grow it without bound
-     * for the life of the request. One `response.completed` event is a few
-     * hundred bytes, so a megabyte is far past any real event, and dropping the
-     * tail costs at most the usage reading this tap is allowed to miss anyway.
-     */
+    // Bound malformed unterminated events without ever withholding relay bytes.
     const CARRY_LIMIT_CHARS = 1024 * 1024;
+    let discardingEvent = false;
     const transformer = {
         transform(chunk, controller) {
             // Bytes go out first and unconditionally: nothing below can delay or
             // alter what the client receives.
             controller.enqueue(chunk);
+            totalBytes += chunk.byteLength;
             try {
                 capture?.(chunk);
                 carry += decoder.decode(chunk, { stream: true });
-                // Keep only the trailing partial line; events are newline-delimited.
-                const lastBreak = carry.lastIndexOf("\n");
-                if (lastBreak === -1) {
-                    if (carry.length > CARRY_LIMIT_CHARS) {
-                        // No line break in a megabyte: this is not the SSE stream we can
-                        // read. Give up on the tail rather than grow forever.
-                        carry = "";
+                if (discardingEvent) {
+                    const boundary = /\r\n\r\n|\n\n|\r\r/.exec(carry);
+                    if (!boundary) {
+                        carry = carry.slice(-3);
+                        return;
                     }
-                    return;
+                    carry = carry.slice(boundary.index + boundary[0].length);
+                    discardingEvent = false;
                 }
-                const complete = carry.slice(0, lastBreak);
-                carry = carry.slice(lastBreak + 1);
-                const seen = scanCodexSSEForUsage(complete);
-                if (seen) {
-                    latest = seen;
+                const { events, remainder } = extractSSEEvents(carry);
+                carry = remainder;
+                inspectEvidence(events);
+                if (carry.length > CARRY_LIMIT_CHARS) {
+                    carry = carry.slice(-2);
+                    discardingEvent = true;
                 }
             }
             catch {
@@ -220,15 +277,7 @@ export function createCodexUsageTap() {
             }
         },
         flush() {
-            try {
-                const seen = scanCodexSSEForUsage(carry);
-                if (seen) {
-                    latest = seen;
-                }
-            }
-            catch {
-                // ignored — see above
-            }
+            // An event without its dispatch delimiter is incomplete on the wire.
             settle(latest);
         },
         /**
@@ -242,5 +291,5 @@ export function createCodexUsageTap() {
         },
     };
     const stream = new TransformStream(transformer);
-    return { stream, usage };
+    return { stream, usage, evidence: () => ({ ...evidence }) };
 }

package/dist/proxy/proxyActivity.d.ts

@@ -1,4 +1,7 @@
-import type { ProxyActivitySnapshot, ProxyResponseTrackingObserver } from "../types/index.js";
+import type { ProxyActivitySnapshot, ProxyResponseTrackingObserver, RequestLogEntry } 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 notifyProxyFinalLog(entry: RequestLogEntry): 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. */