@juspay/neurolink 12.12.6 → 12.12.7

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/proxy.d.ts

@@ -555,6 +555,14 @@ export type ProxyAccountSortMetrics = {
     scopedSaturated: boolean;
 };
 export type RequestLogEntry = {
+    /** First output text or tool-argument delta, excluding SSE control frames. */
+    firstUsefulOutputMs?: number;
+    /** Small routing evidence retained even when response bodies are pruned. */
+    fallbackPlan?: Array<{
+        provider: string;
+        model: string;
+        reasoningEffort?: string;
+    }>;
     timestamp: string;
     requestId: string;
     method: string;
@@ -605,9 +613,31 @@ export type RequestLogEntry = {
     /** Exact secret-free inputs and result of initial account selection. */
     routingDecision?: ProxyAccountRoutingDecision;
 };
+/** File-sink evidence is independent of model/request success counters. */
+export type ProxyRequestLogSinkSnapshot = {
+    attempted: number;
+    written: number;
+    inFlight: number;
+    pending: number;
+    /** Records not admitted because the bounded writer queue was full. */
+    dropped: number;
+    writeTimeouts: number;
+    unconfirmedWrites: number;
+    lastErrorCode?: string;
+};
+export type ProxyRequestLoggerSnapshot = {
+    enabled: boolean;
+    requests: ProxyRequestLogSinkSnapshot;
+    attempts: ProxyRequestLogSinkSnapshot;
+    debug: ProxyRequestLogSinkSnapshot;
+};
 export type RequestAttemptLogEntry = {
     timestamp: string;
     requestId: string;
+    /** Parent client request for an internal fallback invocation. */
+    parentRequestId?: string;
+    /** Requested effort retained independently of full body captures. */
+    reasoningEffort?: string;
     attempt: number;
     method: string;
     path: string;
@@ -649,7 +679,7 @@ export type RequestAttemptLogEntry = {
     spanId?: string;
 };
 /** Additional fields recorded when a Codex response becomes client-final. */
-export type CodexFinalLogExtra = Partial<Pick<RequestLogEntry, "errorType" | "errorMessage" | "errorCode" | "transportScope" | "inputTokens" | "outputTokens" | "cacheReadTokens" | "cacheCreationTokens" | "terminalOutcome">>;
+export type CodexFinalLogExtra = Partial<Pick<RequestLogEntry, "errorType" | "errorMessage" | "errorCode" | "transportScope" | "inputTokens" | "outputTokens" | "cacheReadTokens" | "cacheCreationTokens" | "terminalOutcome" | "firstUsefulOutputMs">>;
 /** Additional fields recorded for each upstream Codex account attempt. */
 export type CodexAttemptLogExtra = Partial<Pick<RequestAttemptLogEntry, "errorType" | "errorMessage" | "errorCode" | "transportScope" | "retryable" | "rateLimitKind" | "cooldownReason">>;
 /** Minimal persistence contract needed by Codex rotating-token refreshes. */
@@ -1580,15 +1610,17 @@ export type ProxyResponseTrackingObserver = {
     }) => void;
     onTerminal?: (details: {
         outcome: ProxyResponseTerminalOutcome;
+        /** Underlying read failure for structured transport diagnostics. */
+        error?: unknown;
         /** Decoded response-body bytes observed by the adapter. */
         observedBodyBytes: number;
         responseChunks: number;
-    }) => void;
+    }) => unknown;
 };
 /** Versioned lifecycle event names persisted by the proxy adapter. */
 export type ProxyLifecycleEventName = "request_accepted" | "response_headers" | "response_first_chunk" | "request_terminal";
 /** Client-facing terminal classifications recorded by lifecycle metadata. */
-export type ProxyLifecycleTerminalOutcome = ProxyResponseTerminalOutcome | "handler_error";
+export type ProxyLifecycleTerminalOutcome = ProxyResponseTerminalOutcome | "handler_error" | "unknown";
 /** Content-free lifecycle event accepted by the bounded metadata logger. */
 export type ProxyLifecycleEventInput = {
     event: ProxyLifecycleEventName;
@@ -1601,6 +1633,13 @@ export type ProxyLifecycleEventInput = {
     sessionHash?: string;
     requestBytes?: number;
     responseStatus?: number;
+    /** Semantic final status; the HTTP status may already have been committed. */
+    finalStatus?: number;
+    /** Terminal bookkeeping health, separate from the model outcome. */
+    telemetryStatus?: "complete" | "timeout" | "observer_error" | "missing_final";
+    /** Transport completion is independent of successful model completion. */
+    transportOutcome?: ProxyResponseTerminalOutcome;
+    outcomeSource?: "final_request" | "transport_error" | "http_status" | "unknown";
     /** Decoded response-body bytes observed by the adapter. */
     observedBodyBytes?: number;
     responseChunks?: number;
@@ -1627,6 +1666,10 @@ export type ProxyLifecycleLoggerSnapshot = {
     writeFailures: number;
     /** Events requeued after a transient lifecycle metadata write failure. */
     writeRetries: number;
+    /** Slow appends still owned by the original writer, never replayed on timeout. */
+    writeTimeouts: number;
+    /** Records in failed appends that may have partially reached the file. */
+    unconfirmedWrites: number;
     pending: number;
     inFlight: number;
     flushing: boolean;
@@ -1698,6 +1741,12 @@ export type ProxyAnalysisReport = {
         unsupportedLifecycleLines: number;
         lifecycleSequenceGaps: number;
         lifecycleSequenceDuplicates: number;
+        conflictingLifecycleDuplicates: number;
+        duplicateAttempts: number;
+        finalOutcomeConflicts: number;
+        /** Missing evidence; may include in-flight or interrupted requests. */
+        acceptedWithoutFinal: number;
+        terminalWithoutFinal: number;
         streams: Record<ProxyAnalysisStreamName, {
             observedFrom: string | null;
             observedTo: string | null;
@@ -1755,6 +1804,7 @@ export type ProxyAnalysisReport = {
     latencyMs: {
         headers: ProxyLatencySummary;
         firstChunk: ProxyLatencySummary;
+        firstUsefulOutput: ProxyLatencySummary;
         terminal: ProxyLatencySummary;
         finalRequest: ProxyLatencySummary;
         attempt: ProxyLatencySummary;
@@ -1817,6 +1867,7 @@ export type ProxyAnalysisAttemptRecord = {
 };
 /** Final request fields retained while joining offline proxy log records. */
 export type ProxyAnalysisFinalRequestRecord = {
+    firstUsefulOutputMs: number | null;
     timestamp: string;
     status: number;
     durationMs: number | null;
@@ -1861,6 +1912,15 @@ export type CodexStreamUsage = {
     cacheCreationTokens: number;
     reasoningTokens: number;
 };
+/** Semantic completion evidence observed in native Codex SSE bytes. */
+export type CodexStreamEvidence = {
+    completed: boolean;
+    terminalBytes: number;
+    firstUsefulOutputAt?: number;
+    errorType?: string;
+    errorMessage?: string;
+    errorCode?: string;
+};
 /** Validated account-routing evidence joined to a final request log. */
 export type ProxyAnalysisRoutingRecord = {
     requestId: string;
@@ -1883,6 +1943,8 @@ export type RuntimeRequestMetadata = {
     rejectForUpdate?: boolean;
     terminalErrorType?: string;
     terminalErrorCode?: string;
+    /** Canonical final record, populated synchronously before asynchronous I/O. */
+    terminalResult?: RequestLogEntry;
     /** Releases this request's peer-share concurrency slot. Set by the share
      *  gate for borrowed traffic; invoked once the response body completes, so a
      *  long stream holds its slot for as long as it is actually streaming. */
@@ -2073,6 +2135,8 @@ export type SSEContentBlock = {
 };
 /** Aggregated telemetry resolved when an SSE stream completes. */
 export type SSETelemetry = {
+    messageStopReceived: boolean;
+    firstUsefulOutputAt?: number;
     messageId: string;
     model: string;
     usage: {
@@ -2115,6 +2179,8 @@ export type StreamTerminalOutcomeTracker = {
 };
 /** Mutable accumulator the SSE interceptor uses internally. */
 export type TelemetryAccumulator = {
+    messageStopReceived: boolean;
+    firstUsefulOutputAt?: number;
     messageId: string;
     model: string;
     inputTokens: number;