@juspay/neurolink 12.12.6 → 12.12.8

package/dist/proxy/requestLogger.js

@@ -17,11 +17,78 @@ import { isBorrowedRequest } from "./shareContext.js";
 import { OtelBridge } from "../observability/otelBridge.js";
 import { SeverityNumber } from "@opentelemetry/api-logs";
 import { configureProxyLifecycleLogger } from "./proxyLifecycle.js";
+import { notifyProxyFinalLog } from "./proxyActivity.js";
 import { withTimeout } from "../utils/async/withTimeout.js";
 let logDir = null;
 let logEnabled = false;
 const pendingLogOperations = new Set();
 const REQUEST_LOG_IO_TIMEOUT_MS = 5_000;
+const MAX_PENDING_METADATA_RECORDS = 4_096;
+const appendChains = new Map();
+let appendMetadataFile = writeFile;
+const createSinkSnapshot = () => ({
+    attempted: 0,
+    written: 0,
+    inFlight: 0,
+    pending: 0,
+    dropped: 0,
+    writeTimeouts: 0,
+    unconfirmedWrites: 0,
+});
+const metadataSinks = {
+    requests: createSinkSnapshot(),
+    attempts: createSinkSnapshot(),
+    debug: createSinkSnapshot(),
+};
+export function getRequestLoggerSnapshot() {
+    return {
+        enabled: logEnabled,
+        requests: { ...metadataSinks.requests },
+        attempts: { ...metadataSinks.attempts },
+        debug: { ...metadataSinks.debug },
+    };
+}
+async function appendMetadataRecord(file, line, kind) {
+    const sink = metadataSinks[kind];
+    sink.attempted += 1;
+    if (sink.pending + sink.inFlight >= MAX_PENDING_METADATA_RECORDS) {
+        sink.dropped += 1;
+        return;
+    }
+    sink.pending += 1;
+    // writeFile may perform multiple append syscalls for a large record. Order
+    // them per destination so concurrent records cannot interleave in this worker.
+    const operation = trackLogOperation((appendChains.get(file) ?? Promise.resolve()).then(async () => {
+        sink.pending -= 1;
+        sink.inFlight += 1;
+        const timer = setTimeout(() => {
+            sink.writeTimeouts += 1;
+        }, REQUEST_LOG_IO_TIMEOUT_MS);
+        timer.unref?.();
+        try {
+            await appendMetadataFile(file, line, { mode: 0o600, flag: "a" });
+            sink.written += 1;
+        }
+        catch (error) {
+            // A failed append may have written a prefix; never replay it.
+            sink.unconfirmedWrites += 1;
+            sink.lastErrorCode =
+                error?.code ?? "UNKNOWN";
+        }
+        finally {
+            clearTimeout(timer);
+            sink.inFlight -= 1;
+        }
+    }));
+    appendChains.set(file, operation);
+    void operation.then(() => {
+        if (appendChains.get(file) === operation) {
+            appendChains.delete(file);
+        }
+    });
+    // Bound the caller's wait, not the lifetime/ownership of the underlying write.
+    await withTimeout(operation, REQUEST_LOG_IO_TIMEOUT_MS, "Proxy metadata write remains pending").catch(() => undefined);
+}
 function trackLogOperation(operation) {
     pendingLogOperations.add(operation);
     void operation.then(() => pendingLogOperations.delete(operation), () => pendingLogOperations.delete(operation));
@@ -33,15 +100,7 @@ export async function flushRequestLogs(timeoutMs = REQUEST_LOG_IO_TIMEOUT_MS) {
     while (pendingLogOperations.size > 0) {
         const admitted = [...pendingLogOperations];
         const remainingMs = Math.max(1, deadline - Date.now());
-        try {
-            await withTimeout(Promise.allSettled(admitted), remainingMs, `Timed out flushing ${admitted.length} proxy request log operation(s)`);
-        }
-        catch (error) {
-            for (const operation of admitted) {
-                pendingLogOperations.delete(operation);
-            }
-            throw error;
-        }
+        await withTimeout(Promise.allSettled(admitted), remainingMs, `Timed out flushing ${admitted.length} proxy request log operation(s)`);
         if (Date.now() >= deadline && pendingLogOperations.size > 0) {
             const remaining = pendingLogOperations.size;
             throw new Error(`Timed out flushing ${remaining} proxy request log operation(s)`);
@@ -52,6 +111,12 @@ export async function flushRequestLogs(timeoutMs = REQUEST_LOG_IO_TIMEOUT_MS) {
 export const __requestLoggerTestHooks = {
     pendingOperationCount: () => pendingLogOperations.size,
     trackLogOperation,
+    setAppendFileForTests: (writer) => {
+        appendMetadataFile = writer;
+    },
+    restoreAppendFileForTests: () => {
+        appendMetadataFile = writeFile;
+    },
 };
 /**
  * Lazily-resolved LoggerProvider from OTel instrumentation.
@@ -104,6 +169,15 @@ export function initRequestLogger(enabled = true, customLogsDir) {
     }
 }
 export async function logRequest(entry) {
+    entry.terminalOutcome ??=
+        entry.errorType === "client_cancelled" || entry.responseStatus === 499
+            ? "client_cancelled"
+            : entry.errorType?.includes("stream")
+                ? "stream_error"
+                : entry.responseStatus >= 400 || entry.errorType
+                    ? "handler_error"
+                    : "completed";
+    notifyProxyFinalLog(entry);
     if (!logEnabled || !logDir) {
         return;
     }
@@ -121,11 +195,7 @@ export async function logRequest(entry) {
     const logFile = join(logDir, `proxy-${new Date().toISOString().split("T")[0]}.jsonl`);
     const line = JSON.stringify(entry) + "\n";
     try {
-        await trackLogOperation(writeFile(logFile, line, {
-            mode: 0o600,
-            flag: "a",
-            signal: AbortSignal.timeout(REQUEST_LOG_IO_TIMEOUT_MS),
-        }));
+        await appendMetadataRecord(logFile, line, "requests");
     }
     catch {
         // Non-fatal — don't crash proxy for logging failures
@@ -153,11 +223,7 @@ export async function logRequestAttempt(entry) {
     const logFile = join(logDir, `proxy-attempts-${new Date().toISOString().split("T")[0]}.jsonl`);
     const line = JSON.stringify(entry) + "\n";
     try {
-        await trackLogOperation(writeFile(logFile, line, {
-            mode: 0o600,
-            flag: "a",
-            signal: AbortSignal.timeout(REQUEST_LOG_IO_TIMEOUT_MS),
-        }));
+        await appendMetadataRecord(logFile, line, "attempts");
     }
     catch {
         // Non-fatal — don't crash proxy for logging failures
@@ -615,11 +681,7 @@ export async function logBodyCapture(entry) {
         indexEntry.spanId = traceCtx.spanId;
     }
     try {
-        await trackLogOperation(writeFile(logFile, JSON.stringify(indexEntry) + "\n", {
-            mode: 0o600,
-            flag: "a",
-            signal: AbortSignal.timeout(REQUEST_LOG_IO_TIMEOUT_MS),
-        }));
+        await appendMetadataRecord(logFile, JSON.stringify(indexEntry) + "\n", "debug");
     }
     catch {
         // Non-fatal
@@ -691,11 +753,7 @@ export async function logStreamError(entry) {
         logEntry.spanId = traceCtx.spanId;
     }
     try {
-        await trackLogOperation(writeFile(logFile, JSON.stringify(logEntry) + "\n", {
-            mode: 0o600,
-            flag: "a",
-            signal: AbortSignal.timeout(REQUEST_LOG_IO_TIMEOUT_MS),
-        }));
+        await appendMetadataRecord(logFile, JSON.stringify(logEntry) + "\n", "requests");
     }
     catch {
         // Non-fatal — don't crash proxy for logging failures

package/dist/proxy/sseInterceptor.js

@@ -50,20 +50,18 @@ export function extractSSEEvents(buffer) {
         const rawBlock = buffer.slice(cursor, boundary);
         cursor = boundary + boundaryMatch[0].length;
         let eventType = "";
-        let dataValue = "";
+        const dataLines = [];
         const lines = rawBlock.split(/\r\n|\n|\r/);
         for (const line of lines) {
-            if (line.startsWith("event: ")) {
-                eventType = line.slice(7).trim();
-            }
-            else if (line.startsWith("data: ")) {
-                dataValue = line.slice(6);
+            if (line.startsWith("event:")) {
+                eventType = line.slice(6).trim();
             }
             else if (line.startsWith("data:")) {
-                // handle `data:` with no space (edge case)
-                dataValue = line.slice(5);
+                const value = line.slice(5);
+                dataLines.push(value.startsWith(" ") ? value.slice(1) : value);
             }
         }
+        const dataValue = dataLines.join("\n");
         if (eventType || dataValue) {
             events.push({ event: eventType, data: dataValue });
         }
@@ -75,6 +73,7 @@ export function extractSSEEvents(buffer) {
 // ---------------------------------------------------------------------------
 function createAccumulator(captureRawText) {
     return {
+        messageStopReceived: false,
         messageId: "",
         model: "",
         inputTokens: 0,
@@ -171,6 +170,8 @@ function finalize(acc) {
     const totalTokens = acc.inputTokens + acc.outputTokens;
     return {
         messageId: acc.messageId,
+        messageStopReceived: acc.messageStopReceived,
+        firstUsefulOutputAt: acc.firstUsefulOutputAt,
         model: acc.model,
         usage: {
             inputTokens: acc.inputTokens,
@@ -327,7 +328,11 @@ function processEvent(acc, event) {
         // Malformed JSON — skip silently, bytes already forwarded to client
         return;
     }
-    if (event.event === "error") {
+    const payloadType = parsed && typeof parsed === "object" && "type" in parsed
+        ? parsed.type
+        : undefined;
+    const eventType = event.event || (typeof payloadType === "string" ? payloadType : "");
+    if (eventType === "error" || payloadType === "error") {
         const payload = parsed && typeof parsed === "object"
             ? parsed
             : {};
@@ -340,7 +345,26 @@ function processEvent(acc, event) {
                 ? truncateString(message.trim(), MAX_EVENT_DATA_BYTES)
                 : truncateString(event.data, MAX_EVENT_DATA_BYTES);
     }
-    switch (event.event) {
+    if (eventType === "message_stop") {
+        acc.messageStopReceived = true;
+    }
+    if (eventType === "content_block_delta" &&
+        parsed &&
+        typeof parsed === "object" &&
+        "delta" in parsed) {
+        const delta = parsed.delta;
+        if (delta &&
+            typeof delta === "object" &&
+            (("text" in delta &&
+                typeof delta.text === "string" &&
+                delta.text.length > 0) ||
+                ("partial_json" in delta &&
+                    typeof delta.partial_json === "string" &&
+                    delta.partial_json.length > 0))) {
+            acc.firstUsefulOutputAt ??= Date.now();
+        }
+    }
+    switch (eventType) {
         case "message_start":
             processMessageStart(acc, parsed);
             break;
@@ -415,14 +439,8 @@ export function createSSEInterceptor(options = {}) {
                 appendRawTextChunk(acc, finalChunk);
                 sseBuffer += finalChunk;
             }
-            // Process any trailing data left in the buffer (e.g. a final event
-            // not followed by a double-newline).
-            if (sseBuffer.trim()) {
-                const { events } = extractSSEEvents(sseBuffer + "\n\n");
-                for (const event of events) {
-                    processEvent(acc, event);
-                }
-            }
+            // SSE dispatch requires a blank line. An unterminated terminal event
+            // is not evidence that the client could observe protocol completion.
             settle();
         },
     });

package/dist/proxy/streamOutcome.d.ts

@@ -2,4 +2,4 @@ import type { AnthropicStreamPreflightResult, StreamTerminalOutcome, StreamTermi
 /** Hold only pre-commit SSE frames so immediate upstream errors remain retryable. */
 export declare function preflightAnthropicStream(reader: ReadableStreamDefaultReader<Uint8Array>): Promise<AnthropicStreamPreflightResult>;
 export declare function createStreamTerminalOutcomeTracker(): StreamTerminalOutcomeTracker;
-export declare function mergeStreamTerminalOutcome(outcome: StreamTerminalOutcome, sseErrorMessage?: string): StreamTerminalOutcome;
+export declare function mergeStreamTerminalOutcome(outcome: StreamTerminalOutcome, sseErrorMessage?: string, messageStopReceived?: boolean): StreamTerminalOutcome;

package/dist/proxy/streamOutcome.js

@@ -95,9 +95,15 @@ export function createStreamTerminalOutcomeTracker() {
         cancel: () => settle({ kind: "client_cancelled" }),
     };
 }
-export function mergeStreamTerminalOutcome(outcome, sseErrorMessage) {
+export function mergeStreamTerminalOutcome(outcome, sseErrorMessage, messageStopReceived) {
     if (outcome.kind === "completed" && sseErrorMessage) {
         return { kind: "upstream_error", message: sseErrorMessage };
     }
+    if (outcome.kind === "completed" && messageStopReceived === false) {
+        return {
+            kind: "upstream_error",
+            message: "Anthropic stream ended without a message_stop event",
+        };
+    }
     return outcome;
 }

package/dist/server/routes/claudeProxyRoutes.js

@@ -26,7 +26,7 @@ import { MAX_COOLDOWN_MS_BY_REASON } from "../../proxy/routingEvidence.js";
 import { buildProxyLimitHeaders, summarizePoolHeadroom, } from "../../proxy/quotaHeaders.js";
 import { buildClaudeError, ClaudeStreamSerializer, generateToolUseId, parseClaudeRequest, serializeClaudeResponse, } from "../../proxy/claudeFormat.js";
 import { CodexFallbackResponseError, consumeCodexFallbackResponse, createCodexFallbackStream, convertClaudeRequestToCodex, } from "../../proxy/codexFallback.js";
-import { registerProxyResponseObserver } from "../../proxy/proxyActivity.js";
+import { registerProxyResponseObserver, takeProxyResponseObservers, trackProxyResponse, } from "../../proxy/proxyActivity.js";
 import { buildAnthropicModelsListResponse, buildTranslationOptions, extractText, extractToolArgs, extractUsageFromStreamResult, handleTranslatedJsonRequest, handleTranslatedStreamRequest, hasTranslatedOutput, } from "../../proxy/proxyTranslationEngine.js";
 import { tracers } from "../../telemetry/tracers.js";
 import { withSpan } from "../../telemetry/withSpan.js";
@@ -2408,6 +2408,7 @@ async function handleClaudePassthroughStreamResponse(args) {
     const trackedStream = trackUpstreamReadableStream(responseBody);
     let streamSource = trackedStream.stream;
     let streamFinalized = false;
+    let telemetryDone;
     const finalizeStream = (status, errorType, errorMessage, usage) => {
         if (streamFinalized) {
             return false;
@@ -2429,9 +2430,14 @@ async function handleClaudePassthroughStreamResponse(args) {
             const capturedUpstreamSpan = upstreamSpan;
             const capturedResponse = response;
             const capturedRequestBytes = bodyStr.length;
-            Promise.all([telemetry, clientCapture, trackedStream.outcome])
+            telemetryDone = Promise.all([
+                telemetry,
+                clientCapture,
+                trackedStream.outcome,
+            ])
                 .then(([data, clientBody, rawOutcome]) => {
-                const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage);
+                const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage, data.messageStopReceived);
+                ctx.metadata.firstUsefulOutputAt = data.firstUsefulOutputAt;
                 const failure = getStreamFailureDetails(terminalOutcome);
                 capturedTracer.setUsage({
                     inputTokens: data.usage.inputTokens,
@@ -2509,7 +2515,7 @@ async function handleClaudePassthroughStreamResponse(args) {
             });
         }
         catch {
-            trackedStream.outcome.then((outcome) => {
+            telemetryDone = trackedStream.outcome.then((outcome) => {
                 const failure = getStreamFailureDetails(outcome);
                 upstreamSpan?.end();
                 if (failure) {
@@ -2526,9 +2532,14 @@ async function handleClaudePassthroughStreamResponse(args) {
                 captureRawText: true,
             });
             streamSource = streamSource.pipeThrough(interceptor);
-            Promise.all([telemetry, clientCapture, trackedStream.outcome])
+            telemetryDone = Promise.all([
+                telemetry,
+                clientCapture,
+                trackedStream.outcome,
+            ])
                 .then(([data, clientBody, rawOutcome]) => {
-                const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage);
+                const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage, data.messageStopReceived);
+                ctx.metadata.firstUsefulOutputAt = data.firstUsefulOutputAt;
                 const failure = getStreamFailureDetails(terminalOutcome);
                 finalizeStream(failure?.status ?? response.status, failure?.errorType, failure?.message, {
                     inputTokens: data.usage.inputTokens,
@@ -2570,13 +2581,16 @@ async function handleClaudePassthroughStreamResponse(args) {
         catch {
             // Streaming capture is best-effort; the tracked source still propagates
             // the transport failure to the client.
-            trackedStream.outcome.then((outcome) => {
+            telemetryDone = trackedStream.outcome.then((outcome) => {
                 const failure = getStreamFailureDetails(outcome);
                 finalizeStream(failure?.status ?? response.status, failure?.errorType, failure?.message);
             });
         }
     }
     const clientStream = streamSource.pipeThrough(clientCaptureStream);
+    registerProxyResponseObserver(ctx.metadata, {
+        onTerminal: () => telemetryDone,
+    });
     return new Response(clientStream, {
         status: response.status,
         // Upstream headers first, then the proxy's own — passthrough already
@@ -3655,7 +3669,21 @@ async function executeClaudeCodexFallback(args) {
         // validation. A failed Codex attempt must not look like a served request.
         responseHeaders: {},
     };
-    const codexResponse = await handleCodexResponsesRequest(codexCtx);
+    const childResponse = await handleCodexResponsesRequest(codexCtx);
+    const childObservers = takeProxyResponseObservers(codexCtx.metadata);
+    let finishChildAccounting = () => { };
+    const childAccounting = new Promise((resolve) => {
+        finishChildAccounting = resolve;
+    });
+    // The translated child has no HTTP runtime of its own. Drive its terminal
+    // observers here so stream failures enrich the actual Codex attempt, while
+    // the parent remains the sole client request in final success/error totals.
+    const codexResponse = trackProxyResponse(childResponse, finishChildAccounting, {
+        onTerminal: (details) => Promise.allSettled(childObservers.map(async (observer) => observer.onTerminal?.(details))),
+    });
+    registerProxyResponseObserver(ctx.metadata, {
+        onTerminal: () => childAccounting,
+    });
     const codexHeaders = { ...(codexCtx.responseHeaders ?? {}) };
     if (body.stream) {
         const bridge = await createCodexFallbackStream(codexResponse, body.model);
@@ -3753,6 +3781,10 @@ async function executeClaudeCodexFallback(args) {
                         return;
                     }
                     const frame = capture(next.value);
+                    if (frame.startsWith("event: content_block_delta\n") &&
+                        /"(?:text|partial_json)":"(?:[^"\\]|\\.)+"/.test(frame)) {
+                        ctx.metadata.firstUsefulOutputAt ??= Date.now();
+                    }
                     if (frame.startsWith("event: message_stop\n")) {
                         // Finalize before exposing the terminal frame: a client can close
                         // immediately after receiving it without making another pull.
@@ -3911,6 +3943,13 @@ async function tryConfiguredClaudeFallbackChain(args) {
     const { ctx, body, parsedFallbackRequest, fallbackPlan: providedFallbackPlan, modelRouter, tracer, requestStartTime, logProxyBody, logFinalRequest, } = args;
     const fallbackPlan = providedFallbackPlan ??
         buildProxyTranslationPlan({ provider: "anthropic", model: body.model }, modelRouter?.getFallbackChain() ?? [], body.model, parsedFallbackRequest);
+    ctx.metadata.fallbackPlan = fallbackPlan.attempts
+        .slice(1)
+        .map(({ provider, model, reasoningEffort }) => ({
+        provider,
+        model,
+        ...(reasoningEffort ? { reasoningEffort } : {}),
+    }));
     logProxyBody({
         phase: "routing_decision",
         contentType: "application/json",
@@ -4669,6 +4708,7 @@ async function handleAnthropicStreamingSuccessResponse(args) {
         attemptNumber,
         finalBodyStr,
         upstreamSpan,
+        logAttempt,
         logProxyBody,
         logFinalRequest,
     });
@@ -4692,13 +4732,14 @@ function getStreamFailureDetails(outcome) {
     }
     return undefined;
 }
-function recordCommittedAnthropicStreamAttemptFailure(outcome, account) {
+function recordCommittedAnthropicStreamAttemptFailure(outcome, account, logAttempt) {
     if (outcome.kind === "upstream_error") {
         recordAttemptError(account.label, account.type, 502);
+        logAttempt(502, "stream_error", outcome.message, { retryable: false });
     }
 }
 function attachAnthropicSuccessStreamTelemetry(args) {
-    const { ctx, account, response, responseHeaders, remainingStream, streamOutcome, tracer, requestStartTime, attemptNumber, finalBodyStr, upstreamSpan, logProxyBody, logFinalRequest, } = args;
+    const { ctx, account, response, responseHeaders, remainingStream, streamOutcome, tracer, requestStartTime, attemptNumber, finalBodyStr, upstreamSpan, logAttempt, logProxyBody, logFinalRequest, } = args;
     const { stream: clientCaptureStream, capture: clientCapture } = createRawStreamCapture();
     let streamSource = remainingStream;
     let telemetryDone;
@@ -4716,8 +4757,9 @@ function attachAnthropicSuccessStreamTelemetry(args) {
             const capturedAccountKey = account.key;
             telemetryDone = Promise.all([telemetry, clientCapture, streamOutcome])
                 .then(([data, clientBody, rawOutcome]) => {
-                const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage);
-                recordCommittedAnthropicStreamAttemptFailure(terminalOutcome, account);
+                const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage, data.messageStopReceived);
+                ctx.metadata.firstUsefulOutputAt = data.firstUsefulOutputAt;
+                recordCommittedAnthropicStreamAttemptFailure(terminalOutcome, account, logAttempt);
                 capturedTracer.setUsage({
                     inputTokens: data.usage.inputTokens,
                     outputTokens: data.usage.outputTokens,
@@ -4814,7 +4856,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
             // still settle the request from the actual stream terminal outcome.
             telemetryDone = streamOutcome
                 .then((outcome) => {
-                recordCommittedAnthropicStreamAttemptFailure(outcome, account);
+                recordCommittedAnthropicStreamAttemptFailure(outcome, account, logAttempt);
                 const failure = getStreamFailureDetails(outcome);
                 upstreamSpan?.end();
                 if (failure) {
@@ -4845,8 +4887,9 @@ function attachAnthropicSuccessStreamTelemetry(args) {
                 streamOutcome,
             ])
                 .then(([data, clientBody, rawOutcome]) => {
-                const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage);
-                recordCommittedAnthropicStreamAttemptFailure(terminalOutcome, account);
+                const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage, data.messageStopReceived);
+                ctx.metadata.firstUsefulOutputAt = data.firstUsefulOutputAt;
+                recordCommittedAnthropicStreamAttemptFailure(terminalOutcome, account, logAttempt);
                 const failure = getStreamFailureDetails(terminalOutcome);
                 const usage = {
                     inputTokens: data.usage.inputTokens,
@@ -4915,7 +4958,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
             });
             telemetryDone = streamOutcome
                 .then((outcome) => {
-                recordCommittedAnthropicStreamAttemptFailure(outcome, account);
+                recordCommittedAnthropicStreamAttemptFailure(outcome, account, logAttempt);
                 const failure = getStreamFailureDetails(outcome);
                 if (failure) {
                     logFinalRequest(failure.status, account.label, account.type, failure.errorType, failure.message);
@@ -4928,6 +4971,9 @@ function attachAnthropicSuccessStreamTelemetry(args) {
         }
     }
     const clientStream = streamSource.pipeThrough(clientCaptureStream);
+    registerProxyResponseObserver(ctx.metadata, {
+        onTerminal: () => telemetryDone,
+    });
     // Limit headers published on the context are applied here rather than left
     // to the runtime wrapper: this Response goes straight to the client on every
     // mount (proxy runtime and the generic server adapters alike), so the
@@ -5958,6 +6004,11 @@ function createClaudeRequestRuntimeContext(args) {
             ...buildClientAttribution(ctx.headers),
             responseStatus: status,
             responseTimeMs: Date.now() - requestStartTime,
+            ...(typeof ctx.metadata.firstUsefulOutputAt === "number"
+                ? {
+                    firstUsefulOutputMs: Math.max(0, ctx.metadata.firstUsefulOutputAt - requestStartTime),
+                }
+                : {}),
             ...(errorType ? { errorType } : {}),
             ...(errorMessage ? { errorMessage } : {}),
             ...(extra?.errorCode ? { errorCode: extra.errorCode } : {}),
@@ -5980,6 +6031,9 @@ function createClaudeRequestRuntimeContext(args) {
                 ? { traceId: traceCtx.traceId, spanId: traceCtx.spanId }
                 : {}),
             ...(routingDecision ? { routingDecision } : {}),
+            ...(Array.isArray(ctx.metadata.fallbackPlan)
+                ? { fallbackPlan: ctx.metadata.fallbackPlan }
+                : {}),
         });
     };
     const buildLoggedClaudeError = (status, message, errorType, extra) => {

package/dist/server/routes/codexProxyRoutes.js

@@ -281,6 +281,13 @@ export async function handleCodexResponsesRequest(ctx) {
     // not an independently final client request. The parent fallback owns the
     // final status and can still recover with a later provider.
     const isFallbackRequest = ctx.metadata?.[CODEX_FALLBACK_METADATA_KEY] === true;
+    const reasoning = body.reasoning;
+    const reasoningEffort = reasoning &&
+        typeof reasoning === "object" &&
+        "effort" in reasoning &&
+        typeof reasoning.effort === "string"
+        ? reasoning.effort
+        : undefined;
     const writeFinalLog = (account, responseStatus, extra = {}) => logRequest({
         timestamp: new Date().toISOString(),
         requestId: ctx.requestId,
@@ -328,6 +335,10 @@ export async function handleCodexResponsesRequest(ctx) {
             timestamp: new Date().toISOString(),
             requestId: ctx.requestId,
             attempt,
+            ...(isFallbackRequest
+                ? { parentRequestId: ctx.requestId.replace(/:codex-fallback$/, "") }
+                : {}),
+            ...(reasoningEffort ? { reasoningEffort } : {}),
             method: ctx.method,
             path: ctx.path,
             model,
@@ -473,23 +484,37 @@ export async function handleCodexResponsesRequest(ctx) {
                     ...(ctx.responseHeaders ?? {}),
                 };
                 if (!upstream.body) {
-                    await recordFinalOutcome(account, upstream.status, {
-                        terminalOutcome: "bodyless",
+                    recordAttemptError(account.label, CODEX_ACCOUNT_TYPE, 502);
+                    writeAttempt(account, attempt, attemptStartedAt, 502, {
+                        errorType: "incomplete_stream",
+                        errorMessage: "Codex returned no response stream",
+                        retryable: false,
+                    });
+                    await recordFinalOutcome(account, 502, {
+                        terminalOutcome: "stream_error",
+                        errorType: "incomplete_stream",
+                        errorMessage: "Codex returned no response stream",
                     });
                     return new Response(upstream.body, {
                         status: upstream.status,
                         headers,
                     });
                 }
-                const { stream: usageTap, usage: usageSeen } = createCodexUsageTap();
+                const { stream: usageTap, usage: usageSeen, evidence, } = createCodexUsageTap();
                 const relay = new Response(upstream.body.pipeThrough(usageTap), {
                     status: upstream.status,
                     headers,
                 });
                 registerProxyResponseObserver(ctx.metadata, {
-                    onTerminal: ({ outcome }) => {
-                        void usageSeen
+                    onTerminal: ({ outcome, error, observedBodyBytes }) => {
+                        return usageSeen
                             .then((usage) => {
+                            const semantic = evidence();
+                            const completedFrameDelivered = semantic.completed &&
+                                observedBodyBytes >= semantic.terminalBytes;
+                            const failed = semantic.errorType ||
+                                ((outcome === "completed" || outcome === "bodyless") &&
+                                    !semantic.completed);
                             const usageExtra = usage
                                 ? {
                                     inputTokens: usage.inputTokens,
@@ -498,10 +523,46 @@ export async function handleCodexResponsesRequest(ctx) {
                                     cacheCreationTokens: usage.cacheCreationTokens,
                                 }
                                 : {};
-                            if (outcome === "completed" || outcome === "bodyless") {
+                            const timing = semantic.firstUsefulOutputAt === undefined
+                                ? {}
+                                : {
+                                    firstUsefulOutputMs: Math.max(0, semantic.firstUsefulOutputAt - requestStartTime),
+                                };
+                            if (failed) {
+                                recordAttemptError(account.label, CODEX_ACCOUNT_TYPE, 502);
+                                writeAttempt(account, attempt, attemptStartedAt, 502, {
+                                    errorType: semantic.errorType ?? "incomplete_stream",
+                                    errorCode: semantic.errorCode,
+                                    errorMessage: semantic.errorMessage ??
+                                        "Codex stream ended without a completion event",
+                                    retryable: false,
+                                });
+                                return recordFinalOutcome(account, 502, {
+                                    ...usageExtra,
+                                    ...timing,
+                                    terminalOutcome: "stream_error",
+                                    errorType: semantic.errorType ?? "incomplete_stream",
+                                    errorCode: semantic.errorCode,
+                                    errorMessage: semantic.errorMessage ??
+                                        "Codex stream ended without a completion event",
+                                });
+                            }
+                            if (outcome === "completed" ||
+                                outcome === "bodyless" ||
+                                (outcome === "client_cancelled" && completedFrameDelivered)) {
                                 return recordFinalOutcome(account, upstream.status, {
-                                    terminalOutcome: outcome,
+                                    terminalOutcome: "completed",
                                     ...usageExtra,
+                                    ...timing,
+                                });
+                            }
+                            if (outcome === "stream_error") {
+                                recordAttemptError(account.label, CODEX_ACCOUNT_TYPE, 502);
+                                writeAttempt(account, attempt, attemptStartedAt, 502, {
+                                    errorType: "stream_error",
+                                    errorCode: getCodexTransportErrorCode(error),
+                                    errorMessage: summarizeCodexUpstreamError(error instanceof Error ? error.message : "", "Codex upstream stream failed"),
+                                    retryable: false,
                                 });
                             }
                             return recordFinalOutcome(account, outcome === "client_cancelled" ? 499 : 502, {
@@ -510,9 +571,13 @@ export async function handleCodexResponsesRequest(ctx) {
                                     : "stream_error",
                                 errorMessage: outcome === "client_cancelled"
                                     ? "Client cancelled Codex stream"
-                                    : "Codex upstream stream failed",
+                                    : summarizeCodexUpstreamError(error instanceof Error ? error.message : "", "Codex upstream stream failed"),
+                                ...(outcome === "stream_error"
+                                    ? { errorCode: getCodexTransportErrorCode(error) }
+                                    : {}),
                                 terminalOutcome: outcome,
                                 ...usageExtra,
+                                ...timing,
                             });
                         })
                             .catch(() => undefined);

package/dist/types/generate.d.ts

@@ -1490,6 +1490,12 @@ export type TextGenerationResult = {
     model?: string;
     usage?: TokenUsage;
     responseTime?: number;
+    /** The executed tool calls of a native turn — the same shape `GenerateResult` exposes. */
+    toolCalls?: Array<{
+        toolCallId: string;
+        toolName: string;
+        args: StandardRecord;
+    }>;
     toolsUsed?: string[];
     toolExecutions?: Array<{
         toolName: string;