@bitkyc08/opencodex 2.58.0 → 2.60.0

package/src/server/request-metrics.ts

@@ -0,0 +1,236 @@
+import type { ResponsesTerminalStatus } from "../bridge";
+import type { AttemptRecoveryKind } from "../usage/log";
+
+export const REQUEST_METRICS_PROTOCOLS = Object.freeze(["responses", "chat", "messages", "unknown"] as const);
+export const REQUEST_METRICS_RESULTS = Object.freeze(["completed", "failed", "incomplete", "aborted"] as const);
+export const REQUEST_METRICS_RECOVERY_CLASSES = Object.freeze([
+  "transient",
+  "connection",
+  "credential",
+  "rate_limit",
+  "payload",
+  "empty_completion",
+  "effort_downgrade",
+  "other",
+] as const);
+
+export const REQUEST_DURATION_BUCKETS_SECONDS = Object.freeze([0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60] as const);
+export const REQUEST_TTFT_BUCKETS_SECONDS = Object.freeze([0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30] as const);
+
+export type RequestMetricsProtocol = typeof REQUEST_METRICS_PROTOCOLS[number];
+export type RequestMetricsResult = typeof REQUEST_METRICS_RESULTS[number];
+export type RequestMetricsRecoveryClass = typeof REQUEST_METRICS_RECOVERY_CLASSES[number];
+
+export interface RequestMetricFinalFact {
+  protocol?: "responses" | "chat" | "messages";
+  status: number;
+  durationMs: number;
+  firstOutputMs?: number;
+  terminalStatus?: ResponsesTerminalStatus;
+  closeReason?: "terminal" | "client_cancel" | "non_stream" | "body_stall" | "body_overflow";
+  attempts?: ReadonlyArray<{
+    sendCount: number;
+    recoveryKinds: readonly AttemptRecoveryKind[];
+  }>;
+  spendSends?: number;
+}
+
+export interface RequestMetricsRecorder {
+  recordFinalRequest(fact: RequestMetricFinalFact): void;
+}
+
+export interface RequestMetricsSnapshotter {
+  snapshot(): string;
+}
+
+export interface RequestMetricsOwner extends RequestMetricsRecorder, RequestMetricsSnapshotter {
+  resetForTests(): void;
+}
+
+interface HistogramCell {
+  buckets: number[];
+  count: number;
+  sum: number;
+}
+
+const protocolCell = (value: RequestMetricsProtocol): number => REQUEST_METRICS_PROTOCOLS.indexOf(value);
+const resultCell = (value: RequestMetricsResult): number => REQUEST_METRICS_RESULTS.indexOf(value);
+const recoveryCell = (value: RequestMetricsRecoveryClass): number => REQUEST_METRICS_RECOVERY_CLASSES.indexOf(value);
+
+function matrix(rows: number, columns: number): number[][] {
+  return Array.from({ length: rows }, () => Array.from({ length: columns }, () => 0));
+}
+
+function histograms(bounds: readonly number[]): HistogramCell[][] {
+  return Array.from({ length: REQUEST_METRICS_PROTOCOLS.length }, () => (
+    Array.from({ length: REQUEST_METRICS_RESULTS.length }, () => ({
+      buckets: Array.from({ length: bounds.length + 1 }, () => 0),
+      count: 0,
+      sum: 0,
+    }))
+  ));
+}
+
+function classifyResult(fact: RequestMetricFinalFact): RequestMetricsResult {
+  if (fact.closeReason === "client_cancel" || fact.status === 499) return "aborted";
+  if (fact.terminalStatus === "failed") return "failed";
+  if (fact.terminalStatus === "incomplete"
+    || fact.closeReason === "body_stall"
+    || fact.closeReason === "body_overflow") return "incomplete";
+  if (fact.terminalStatus === "completed") return "completed";
+  if (fact.terminalStatus === undefined
+    && (fact.status === 101 || (fact.status >= 200 && fact.status < 400))) return "completed";
+  return "failed";
+}
+
+function recoveryClass(kind: AttemptRecoveryKind): RequestMetricsRecoveryClass {
+  switch (kind) {
+    case "transient-5xx": return "transient";
+    case "connection-reset": return "connection";
+    case "oauth-401":
+    case "key-401": return "credential";
+    case "key-429":
+    case "rate-limit-429":
+    case "anthropic-oauth-429":
+    case "oauth-account-429": return "rate_limit";
+    case "image-413":
+    case "console-go-upload-retry":
+    case "opaque-blob-rejection": return "payload";
+    case "empty-completion": return "empty_completion";
+    case "reasoning-effort-downgrade": return "effort_downgrade";
+    default: return "other";
+  }
+}
+
+function observeHistogram(cell: HistogramCell, bounds: readonly number[], value: number): void {
+  if (!Number.isFinite(value) || value < 0) return;
+  cell.count += 1;
+  cell.sum += value;
+  for (let index = 0; index < bounds.length; index += 1) {
+    if (value <= bounds[index]!) cell.buckets[index]! += 1;
+  }
+  cell.buckets[bounds.length]! += 1;
+}
+
+function sampleLabels(protocol: RequestMetricsProtocol, result?: RequestMetricsResult): string {
+  return result === undefined
+    ? `{protocol="${protocol}"}`
+    : `{protocol="${protocol}",result="${result}"}`;
+}
+
+function appendHistogram(
+  lines: string[],
+  name: string,
+  help: string,
+  values: HistogramCell[][],
+  bounds: readonly number[],
+): void {
+  lines.push(`# HELP ${name} ${help}`, `# TYPE ${name} histogram`);
+  for (const protocol of REQUEST_METRICS_PROTOCOLS) {
+    for (const result of REQUEST_METRICS_RESULTS) {
+      const cell = values[protocolCell(protocol)]![resultCell(result)]!;
+      for (let index = 0; index < bounds.length; index += 1) {
+        lines.push(`${name}_bucket{protocol="${protocol}",result="${result}",le="${bounds[index]}"} ${cell.buckets[index]}`);
+      }
+      lines.push(`${name}_bucket{protocol="${protocol}",result="${result}",le="+Inf"} ${cell.buckets[bounds.length]}`);
+      lines.push(`${name}_sum${sampleLabels(protocol, result)} ${cell.sum}`);
+      lines.push(`${name}_count${sampleLabels(protocol, result)} ${cell.count}`);
+    }
+  }
+}
+
+export function createRequestMetricsOwner(
+  processStartTimeSeconds = Date.now() / 1000,
+): RequestMetricsOwner {
+  let logicalRequests = matrix(REQUEST_METRICS_PROTOCOLS.length, REQUEST_METRICS_RESULTS.length);
+  let physicalSends = Array.from({ length: REQUEST_METRICS_PROTOCOLS.length }, () => 0);
+  let recoveries = matrix(REQUEST_METRICS_PROTOCOLS.length, REQUEST_METRICS_RECOVERY_CLASSES.length);
+  let durations = histograms(REQUEST_DURATION_BUCKETS_SECONDS);
+  let ttft = histograms(REQUEST_TTFT_BUCKETS_SECONDS);
+  let missingTtft = matrix(REQUEST_METRICS_PROTOCOLS.length, REQUEST_METRICS_RESULTS.length);
+
+  return {
+    recordFinalRequest(fact): void {
+      const protocol: RequestMetricsProtocol = fact.protocol ?? "unknown";
+      const result = classifyResult(fact);
+      const protocolIndex = protocolCell(protocol);
+      const resultIndex = resultCell(result);
+      logicalRequests[protocolIndex]![resultIndex]! += 1;
+
+      const attempts = fact.attempts;
+      const sends = attempts === undefined
+        ? (Number.isInteger(fact.spendSends) && fact.spendSends! >= 0 ? fact.spendSends! : 0)
+        : attempts.reduce((total, attempt) => (
+          Number.isInteger(attempt.sendCount) && attempt.sendCount >= 0 ? total + attempt.sendCount : total
+        ), 0);
+      physicalSends[protocolIndex]! += sends;
+
+      for (const attempt of attempts ?? []) {
+        for (const kind of new Set(attempt.recoveryKinds)) {
+          recoveries[protocolIndex]![recoveryCell(recoveryClass(kind))]! += 1;
+        }
+      }
+
+      observeHistogram(durations[protocolIndex]![resultIndex]!, REQUEST_DURATION_BUCKETS_SECONDS, fact.durationMs / 1000);
+      if (typeof fact.firstOutputMs === "number" && Number.isFinite(fact.firstOutputMs) && fact.firstOutputMs >= 0) {
+        observeHistogram(ttft[protocolIndex]![resultIndex]!, REQUEST_TTFT_BUCKETS_SECONDS, fact.firstOutputMs / 1000);
+      } else {
+        missingTtft[protocolIndex]![resultIndex]! += 1;
+      }
+    },
+
+    snapshot(): string {
+      const lines: string[] = [
+        "# HELP opencodex_logical_requests_total Finalized logical requests in this process.",
+        "# TYPE opencodex_logical_requests_total counter",
+      ];
+      for (const protocol of REQUEST_METRICS_PROTOCOLS) {
+        for (const result of REQUEST_METRICS_RESULTS) {
+          lines.push(`opencodex_logical_requests_total${sampleLabels(protocol, result)} ${logicalRequests[protocolCell(protocol)]![resultCell(result)]}`);
+        }
+      }
+      lines.push(
+        "# HELP opencodex_physical_sends_total Upstream sends made by finalized logical requests in this process.",
+        "# TYPE opencodex_physical_sends_total counter",
+      );
+      for (const protocol of REQUEST_METRICS_PROTOCOLS) {
+        lines.push(`opencodex_physical_sends_total${sampleLabels(protocol)} ${physicalSends[protocolCell(protocol)]}`);
+      }
+      lines.push(
+        "# HELP opencodex_recoveries_total Distinct recovery kinds observed per physical attempt in this process.",
+        "# TYPE opencodex_recoveries_total counter",
+      );
+      for (const protocol of REQUEST_METRICS_PROTOCOLS) {
+        for (const recovery of REQUEST_METRICS_RECOVERY_CLASSES) {
+          lines.push(`opencodex_recoveries_total{protocol="${protocol}",recovery="${recovery}"} ${recoveries[protocolCell(protocol)]![recoveryCell(recovery)]}`);
+        }
+      }
+      appendHistogram(lines, "opencodex_request_duration_seconds", "Finalized logical request duration in seconds.", durations, REQUEST_DURATION_BUCKETS_SECONDS);
+      appendHistogram(lines, "opencodex_ttft_seconds", "Observed time to first output in seconds.", ttft, REQUEST_TTFT_BUCKETS_SECONDS);
+      lines.push(
+        "# HELP opencodex_ttft_missing_total Finalized logical requests without an observed time to first output.",
+        "# TYPE opencodex_ttft_missing_total counter",
+      );
+      for (const protocol of REQUEST_METRICS_PROTOCOLS) {
+        for (const result of REQUEST_METRICS_RESULTS) {
+          lines.push(`opencodex_ttft_missing_total${sampleLabels(protocol, result)} ${missingTtft[protocolCell(protocol)]![resultCell(result)]}`);
+        }
+      }
+      lines.push(
+        "# HELP opencodex_metrics_process_start_time_seconds Unix time when this process metrics owner started.",
+        "# TYPE opencodex_metrics_process_start_time_seconds gauge",
+        `opencodex_metrics_process_start_time_seconds ${processStartTimeSeconds}`,
+      );
+      return `${lines.join("\n")}\n`;
+    },
+
+    resetForTests(): void {
+      logicalRequests = matrix(REQUEST_METRICS_PROTOCOLS.length, REQUEST_METRICS_RESULTS.length);
+      physicalSends = Array.from({ length: REQUEST_METRICS_PROTOCOLS.length }, () => 0);
+      recoveries = matrix(REQUEST_METRICS_PROTOCOLS.length, REQUEST_METRICS_RECOVERY_CLASSES.length);
+      durations = histograms(REQUEST_DURATION_BUCKETS_SECONDS);
+      ttft = histograms(REQUEST_TTFT_BUCKETS_SECONDS);
+      missingTtft = matrix(REQUEST_METRICS_PROTOCOLS.length, REQUEST_METRICS_RESULTS.length);
+    },
+  };
+}

package/src/server/responses/adapter-continuation.ts

@@ -13,6 +13,7 @@ import {
   sealRequestAttemptIdentity,
   recordAttemptCredentialSource,
 } from "../request-log";
+import { noteAttemptRecoveryWithheld } from "../request-log";
 import { waitForProviderRequestSlot } from "../../providers/request-pacing";
 import { providerFetch, fetchWithHeaderTimeout, safeHostLabel } from "./fetch-helpers";
 import {
@@ -46,7 +47,12 @@ import {
 import { shouldAttemptImageTierRetry } from "../image-retry";
 import { readDisplaySafeErrorText, normalizeUpstreamErrorText } from "./core-errors";
 import { isCyberPolicyCode, CYBER_POLICY_FALLBACK_MESSAGE, CYBER_POLICY_ERROR_CODE } from "../../lib/errors";
-import { cancelBodyOnAbort } from "../../lib/abort";
+import {
+  readResponseBodyWithInactivity,
+  readResponseStreamWithInactivity,
+  ResponseBodyInactivityError,
+} from "../../lib/response-body-inactivity";
+import { resolveStallTimeoutSec } from "../../stall-timeout";
 import { guardTerminalEventStream } from "./terminal-guard";
 
 /** One responsibility of the Responses request pipeline; state owners are explicit. */
@@ -78,6 +84,7 @@ export function createAdapterContinuations(
     | "genericFailoverAccountId"
     | "genericFailovers"
     | "applyFailoverSnapshot"
+    | "replayOAuthCredentialSnapshot"
     | "noteRoutedAttemptSend"
   >,
   sidecarState: Pick<ResponsesSidecarAuth, "routedCompaction">,
@@ -85,6 +92,7 @@ export function createAdapterContinuations(
     ResponsesSendBudget,
     | "adapterDispatchBudget"
     | "noteAdapterPhysicalSend"
+    | "noteAdapterRecoveryWithheld"
     | "remainingTransientSendBudget"
     | "noteTransientSends"
     | "reserveCredentialHop"
@@ -112,9 +120,11 @@ export function createAdapterContinuations(
   const { route, translatorBudget, inboundWire, parsed } = requestState;
   const { routedCompaction } = sidecarState;
   const { upstream, connectMs, rateLimitPolicy, stallTimeoutMs } = adapterExchange;
+  const bodyInactivityMs = resolveStallTimeoutSec(config.stallTimeoutSec) * 1000;
   const {
     adapterDispatchBudget,
     noteAdapterPhysicalSend,
+    noteAdapterRecoveryWithheld,
     remainingTransientSendBudget,
     noteTransientSends,
     reserveCredentialHop,
@@ -193,6 +203,7 @@ export function createAdapterContinuations(
             timeoutMs: connectMs,
               sendBudget: adapterDispatchBudget,
             onPhysicalSend: send => noteAdapterPhysicalSend(continuationEstimate, send),
+            onRecoveryWithheld: noteAdapterRecoveryWithheld,
             stream: nextParsed.stream,
             executor: providerFetch(route.provider, options.codexWsRuntimeIdentity, {
               pacingSlotAcquired: true,
@@ -263,12 +274,12 @@ export function createAdapterContinuations(
       // Same-target 429 wait-and-retry (opt-in `retryOn429`) before key/account failover:
       // a primary-key rate-limit blip replays on the SAME key, matching the main recovery
       // loop; only after the attempts are exhausted does the continuation fail over.
-      while (
-        response.status === 429
+     while (
+       response.status === 429
         // A synthesized replay refusal is not a rate limit; replaying the continuation on
         // it would re-send a turn whose first send may already have been processed.
         && !isNonReplayableResponse(response)
-        && rateLimitPolicy !== null
+       && rateLimitPolicy !== null
         && adapterExchange.rateLimitRetries < rateLimitPolicy.attempts
         // The main recovery loop and the passthrough ladder both consult the shared remainder
         // here; this loop did not, so a request whose budget was already spent could still
@@ -327,7 +338,7 @@ export function createAdapterContinuations(
           route.provider = rotated;
           invalidateSameTargetRequest();
           transportState.activeAdapter = resolveSelectionAdapter(
-            resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire),
+            resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire, route.staticPolicy),
             config.cacheRetention,
           );
           bindRouteReasoningReplayScope({
@@ -348,11 +359,11 @@ export function createAdapterContinuations(
           continue;
         }
       }
-      if (
-        response.status === 429
+     if (
+       response.status === 429
+       && transportState.anthropicPoolAccountId
         && !isNonReplayableResponse(response)
-        && transportState.anthropicPoolAccountId
-        && transportState.anthropicPoolFailovers < ANTHROPIC_POOL_MAX_FAILOVERS_PER_REQUEST
+       && transportState.anthropicPoolFailovers < ANTHROPIC_POOL_MAX_FAILOVERS_PER_REQUEST
       ) {
         const nextAccountId = rotateAnthropicAccountOn429(
           config,
@@ -373,7 +384,7 @@ export function createAdapterContinuations(
             invalidateSameTargetRequest();
             logCtx.provider = formatAnthropicProviderForLog("anthropic", admitted.accountId, config);
             transportState.activeAdapter = resolveSelectionAdapter(
-              resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire),
+              resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire, route.staticPolicy),
               config.cacheRetention,
             );
             sealRequestAttemptIdentity(logCtx.activeAttempt, logCtx.provider, transportState.activeAdapter.name, logCtx.accountLogLabel);
@@ -390,11 +401,11 @@ export function createAdapterContinuations(
       // 429 stayed terminal even with failover fully active -- the same class of divergence the
       // two sidecars already produced once. Request-local state is shared with the other arms so
       // the per-request bound cannot be silently re-armed by reaching a different loop.
-      if (
-        response.status === 429
+     if (
+       response.status === 429
+       && transportState.genericFailoverAccountId
         && !isNonReplayableResponse(response)
-        && transportState.genericFailoverAccountId
-        && transportState.genericFailovers < GENERIC_OAUTH_MAX_FAILOVERS_PER_REQUEST
+       && transportState.genericFailovers < GENERIC_OAUTH_MAX_FAILOVERS_PER_REQUEST
         && isGenericOAuthFailoverEnabled(config, route.providerName)
       ) {
         // Intersection with the shared request budget. The continuation loop re-sends the
@@ -416,8 +427,13 @@ export function createAdapterContinuations(
             route.providerName,
             transportState.genericFailoverAccountId,
             response.headers.get("retry-after"),
+            Date.now(),
+            route.modelId,
           )
           : null;
+        // Eligible and refused by the shared budget, as opposed to eligible and finding no next
+        // account: the two produce the same response and need different follow-ups (#5044).
+        if (!hop.allowed) noteAttemptRecoveryWithheld(logCtx.activeAttempt, "rotation-send-budget");
         if (!nextAccountId) hop.permit?.release();
         if (nextAccountId) {
           try { void response.body?.cancel().catch(() => {}); } catch { /* already closed */ }
@@ -433,9 +449,25 @@ export function createAdapterContinuations(
             if (applied) {
               invalidateSameTargetRequest();
               transportState.activeAdapter = resolveSelectionAdapter(
-                resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire),
+                resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire, route.staticPolicy),
                 config.cacheRetention,
               );
+              bindRouteReasoningReplayScope({
+                parsed: nextParsed,
+                providerName: route.providerName,
+                provider: route.provider,
+                adapterName: transportState.activeAdapter.name,
+                oauthCredentialSnapshot: transportState.replayOAuthCredentialSnapshot,
+              });
+              // Response persistence closes over the outer parsed request; keep its owner binding in
+              // sync with the terminal-guard clone that builds the rotated continuation request.
+              bindRouteReasoningReplayScope({
+                parsed,
+                providerName: route.providerName,
+                provider: route.provider,
+                adapterName: transportState.activeAdapter.name,
+                oauthCredentialSnapshot: transportState.replayOAuthCredentialSnapshot,
+              });
               sealRequestAttemptIdentity(logCtx.activeAttempt, logCtx.provider, transportState.activeAdapter.name, logCtx.accountLogLabel);
               recordAttemptCredentialSource(logCtx.activeAttempt, route.providerName, route.provider, transportState.activeAdapter.name);
               // The replay goes out on the next iteration. An adapter that owns its ladder
@@ -493,23 +525,35 @@ export function createAdapterContinuations(
     }
 
     try {
-      // Protect the continuation body against a client abort landing between fetch resolution and
-      // reader attach, exactly as the initial response is guarded above (#390/366e3053). Without
-      // this, a client cancel during the continuation reopens the Bun fetch-to-reader abort race.
-      const detachContinuationBodyGuard = cancelBodyOnAbort(response.body, upstream.signal);
-      try {
-        if (nextParsed.stream) {
-          yield* transportState.activeAdapter.parseStream(response, translatorBudget, logCtx.activeTierMetadata);
-        } else if (transportState.activeAdapter.parseResponse) {
-          yield* await transportState.activeAdapter.parseResponse(response, translatorBudget, logCtx.activeTierMetadata);
-        } else {
-          yield { type: "error", message: "Provider continuation does not support response parsing" };
-        }
-      } finally {
-        detachContinuationBodyGuard();
+      // Each successful continuation owns a fresh pending-read deadline and an abort
+      // listener that can cancel its reader even while the parser holds the body lock.
+      // The shared signal is not aborted on timeout: this generator must still emit
+      // the error that the already-live Responses bridge turns into a terminal.
+      if (nextParsed.stream) {
+        yield* readResponseStreamWithInactivity(
+          response,
+          upstream.signal,
+          bodyInactivityMs,
+          guarded => transportState.activeAdapter.parseStream(guarded, translatorBudget, logCtx.activeTierMetadata),
+        );
+      } else if (transportState.activeAdapter.parseResponse) {
+        yield* await readResponseBodyWithInactivity(
+          response,
+          upstream.signal,
+          bodyInactivityMs,
+          guarded => transportState.activeAdapter.parseResponse!(guarded, translatorBudget, logCtx.activeTierMetadata),
+        );
+      } else {
+        try { void response.body?.cancel().catch(() => {}); } catch { /* already closed */ }
+        yield { type: "error", message: "Provider continuation does not support response parsing" };
       }
     } catch (error) {
-      if (options.abortSignal?.aborted) {
+      // Classify the thrown error before reading signal state: cancelling the stalled
+      // source can synchronously abort the shared signal, which would otherwise report
+      // this timeout as a client cancellation.
+      if (error instanceof ResponseBodyInactivityError) {
+        yield { type: "error", message: "Provider continuation response body stalled before completing", status: 504 };
+      } else if (options.abortSignal?.aborted || upstream.signal.aborted) {
         yield { type: "error", message: "client closed request during terminal continuation", status: 499 };
       } else {
         yield { type: "error", message: `Provider continuation parse failed: ${redactSecretString(error instanceof Error ? error.message : String(error))}` };

package/src/server/responses/adapter-delivery.ts

@@ -14,6 +14,12 @@ import { rememberResponseState } from "../../responses/state";
 import { trackStreamLifetime } from "../lifecycle";
 import { awaitThoughtSignatureDurability } from "../../responses/thought-signature-replay";
 import { adapterResponseReachedServingTerminal } from "./core-replay";
+import {
+  readResponseBodyWithInactivity,
+  readResponseStreamWithInactivity,
+  ResponseBodyInactivityError,
+} from "../../lib/response-body-inactivity";
+import { resolveStallTimeoutSec } from "../../stall-timeout";
 
 /** One responsibility of the Responses request pipeline; state owners are explicit. */
 export async function deliverAdapterResponse(
@@ -61,14 +67,33 @@ export async function deliverAdapterResponse(
     notifyResponseComplete,
   } = responseEffects;
   const { routedCompaction } = sidecarState;
+  const bodyInactivityMs = resolveStallTimeoutSec(config.stallTimeoutSec) * 1000;
 
 
   if (parsed.stream) {
-    const initialEventStream = transportState.activeAdapter.parseStream(
-      upstreamResponse,
-      translatorBudget,
-      logCtx.activeTierMetadata,
-    );
+    // The continuation legs classify a stalled body themselves; the initial stream needs the
+    // same mapping or the bridge catch reports this upstream timeout as a 500 proxy_error.
+    const initialEventStream = (async function* (): AsyncGenerator<AdapterEvent> {
+      try {
+        yield* readResponseStreamWithInactivity(
+          upstreamResponse,
+          upstream.signal,
+          bodyInactivityMs,
+          response => transportState.activeAdapter.parseStream(response, translatorBudget, logCtx.activeTierMetadata),
+        );
+      } catch (error) {
+        if (error instanceof ResponseBodyInactivityError) {
+          yield {
+            type: "error",
+            message: "Upstream response body stalled before completing",
+            status: 504,
+            errorType: "upstream_error",
+          };
+          return;
+        }
+        throw error;
+      }
+    })();
     const eventStream = terminalGuardEnabled
       ? guardTerminalEventStream({
           parsed,
@@ -137,10 +162,11 @@ export async function deliverAdapterResponse(
   if (transportState.activeAdapter.parseResponse) {
     let events: AdapterEvent[];
     try {
-      const initialEvents = await transportState.activeAdapter.parseResponse(
+      const initialEvents = await readResponseBodyWithInactivity(
         upstreamResponse,
-        translatorBudget,
-        logCtx.activeTierMetadata,
+        upstream.signal,
+        bodyInactivityMs,
+        response => transportState.activeAdapter.parseResponse!(response, translatorBudget, logCtx.activeTierMetadata),
       );
       let guardedEvents: AdapterEvent[];
       if (terminalGuardEnabled) {
@@ -164,6 +190,11 @@ export async function deliverAdapterResponse(
       } else {
         events = guardedEvents;
       }
+    } catch (error) {
+      if (error instanceof ResponseBodyInactivityError) {
+        return formatErrorResponse(504, "upstream_error", "Upstream response body stalled before completing");
+      }
+      throw error;
     } finally {
       cleanupUpstreamAbort();
     }