cartethyia 2.7.8 → 2.8.0

package/src/providers/quota/refresh.ts

@@ -11,12 +11,14 @@ import type { CartethyiaDatabase } from "../../persistence/db-handle";
 import { providerAccounts } from "../../persistence/schema";
 import type { RedisClient } from "../../persistence/redis";
 import { log } from "../../observability/logger";
+import { pushStructuredConsoleLog } from "../../observability/log-ring";
 import { fetchProviderQuota } from "./quota-support";
 import { type FetchLike, type ProviderQuotaResult } from "./quota-contracts";
 import type { ProviderId } from "../provider-contracts";
 import type { ProviderRegistry } from "../provider-registry";
 import { quotaLens, setCachedQuota } from "./cache";
 import { persistQuotaSnapshot } from "./snapshot";
+import { applyAccountVerdict } from "../operations/account-health-service";
 import { asJsonbRecord } from "../../shared/coerce";
 import { KIRO_DEFAULT_LABELS } from "../integrations/kiro/kiro-oauth";
 
@@ -149,12 +151,52 @@ export async function recordAccountCheck(
   db: CartethyiaDatabase,
   accountId: string,
   outcome: { ok: boolean; error?: string | null; category?: string | null },
+  snapshotInvalidator?: { invalidate(): unknown },
 ): Promise<void> {
-  const activeOnly = and(
-    eq(providerAccounts.id, accountId),
-    eq(providerAccounts.status, "active"),
-  );
   if (outcome.ok) {
+    // A successful quota refresh is the freshest evidence about the account's
+    // health: heal a cooldown that the refresh shows is no longer justified, so
+    // the account returns to rotation immediately instead of waiting out the
+    // remainder of a stale fallback window. Only healable scopes heal — an
+    // auth/policy cooldown must never be lifted by a quota report (the
+    // credential is still refused). `lastErrorCategory` carries the category
+    // that parked the account, so the heal is scoped by the same verdict the
+    // health machine wrote.
+    const healableCategories = new Set([
+      "quota_exhausted",
+      "rate_limit_transient",
+      "model_capacity",
+      "model_unreachable",
+      "unknown",
+      "check_failed",
+    ]);
+    const rows = await db
+      .select({ status: providerAccounts.status, lastErrorCategory: providerAccounts.lastErrorCategory })
+      .from(providerAccounts)
+      .where(eq(providerAccounts.id, accountId))
+      .limit(1);
+    const account = rows[0];
+    const healable =
+      account?.status === "cooldown" &&
+      (account.lastErrorCategory === null || healableCategories.has(account.lastErrorCategory));
+    if (healable) {
+      const healed = await db
+        .update(providerAccounts)
+        .set({
+          status: "active",
+          lastSuccessAt: new Date(),
+          lastError: null,
+          lastErrorCategory: null,
+          lastErrorAt: null,
+          consecutiveFailures: 0,
+          cooldownUntil: null,
+          lastRecoveredAt: new Date(),
+        })
+        .where(eq(providerAccounts.id, accountId))
+        .returning({ id: providerAccounts.id });
+      if (healed.length > 0) await snapshotInvalidator?.invalidate();
+      return;
+    }
     await db
       .update(providerAccounts)
       .set({
@@ -164,7 +206,7 @@ export async function recordAccountCheck(
         lastErrorAt: null,
         consecutiveFailures: 0,
       })
-      .where(activeOnly);
+      .where(and(eq(providerAccounts.id, accountId), eq(providerAccounts.status, "active")));
     return;
   }
   const transient = isTransientTimeout(outcome.error);
@@ -185,7 +227,7 @@ export async function recordAccountCheck(
       lastErrorAt: new Date(),
       ...(transient ? {} : { consecutiveFailures: sql`${providerAccounts.consecutiveFailures} + 1` }),
     })
-    .where(activeOnly)
+    .where(and(eq(providerAccounts.id, accountId), eq(providerAccounts.status, "active")))
     .returning({ consecutiveFailures: providerAccounts.consecutiveFailures });
   if (transient) return;
   const failures = failing[0]?.consecutiveFailures ?? 0;
@@ -195,13 +237,18 @@ export async function recordAccountCheck(
   // pass. The cooldown clears itself; a success before it elapses resets the
   // count above.
   if (failures >= QUOTA_FAILURE_PARK_THRESHOLD) {
-    await db
-      .update(providerAccounts)
-      .set({
-        status: "cooldown",
-        cooldownUntil: new Date(Date.now() + QUOTA_FAILURE_COOLDOWN_MS),
-      })
-      .where(activeOnly);
+    // Converge on the health application seam (proposal §3.5): quota refresh
+    // parking is a producer into `applyAccountVerdict`, not a separate state
+    // machine.
+    const parked = await applyAccountVerdict(db, {
+      accountId,
+      status: "cooldown",
+      reason: outcome.error ?? "Account check failed",
+      category: outcome.category ?? "quota_fetch_failed",
+      cooldownUntil: new Date(Date.now() + QUOTA_FAILURE_COOLDOWN_MS),
+      fromStatus: "active",
+    });
+    if (parked) await snapshotInvalidator?.invalidate();
   }
 }
 
@@ -261,6 +308,12 @@ const TARGET_COLUMNS = {
  * disabled account is not necessarily revoked — it may have been parked for a
  * reason unrelated to its credential — and skipping it would let a credential
  * die silently while the row still reads healthy.
+ *
+ * Invariant (area 04, D21): this sweep **never flips status**. The refresh it
+ * kicks off rewrites only credential/expiry columns; `recordAccountCheck` is
+ * active-only, so `disabled` rows are identical after the pass to before. The
+ * `origin: "sweep:quota"` tag on the token-refresh log lines (D26) is what
+ * lets an operator verify that in the Console Log.
  */
 export async function listQuotaRefreshTargets(
   db: CartethyiaDatabase,
@@ -343,6 +396,20 @@ async function runQuotaRefresh(
   let resolveError: string | undefined;
   try {
     credential = await deps.resolveCredential(target.providerId as ProviderId, target.accountId);
+    // D26: every OAuth credential this sweep resolves may have been refreshed
+    // inside the refresh-aware resolver. Label that refresh with its origin so
+    // the Console Log can prove the sweep touches disabled accounts without
+    // ever flipping their status. The refresh service itself also logs the
+    // actual token refresh under the `sweep` origin family; this line names
+    // the sweep here, at the source of the trigger.
+    if (credential !== "" && target.credentialKind === "oauth") {
+      pushStructuredConsoleLog("debug", "Quota sweep resolved OAuth credential; token may have been refreshed", {
+        event: "token_refresh",
+        accountId: target.accountId,
+        providerId: target.providerId,
+        details: { origin: "sweep:quota" },
+      });
+    }
   } catch (error) {
     resolveError = error instanceof Error ? error.message : "Failed to resolve credential";
   }
@@ -406,7 +473,13 @@ async function runQuotaRefresh(
     try {
       await deps.db
         .update(providerAccounts)
-        .set({ quotaPlan: quota.plan })
+        .set({
+          quotaPlan: quota.plan,
+          // Freshness stamp for the plan column: routing uses it to downgrade
+          // a plan older than the freshness horizon to `unknown` instead of
+          // trusting a weeks-old string.
+          quotaPlanFetchedAt: new Date(),
+        })
         .where(eq(providerAccounts.id, target.accountId));
     } catch (error) {
       log.warn(`[quota] failed to record plan for account=${target.accountId}`, error as Error);
@@ -448,10 +521,15 @@ async function runQuotaRefresh(
     }
   }
   try {
-    await recordAccountCheck(deps.db, target.accountId, {
-      ok: quota.error === null,
-      ...(quota.error === null ? {} : { error: quota.error, category: failure ?? "quota_fetch_failed" }),
-    });
+    await recordAccountCheck(
+      deps.db,
+      target.accountId,
+      {
+        ok: quota.error === null,
+        ...(quota.error === null ? {} : { error: quota.error, category: failure ?? "quota_fetch_failed" }),
+      },
+      deps.snapshotInvalidator,
+    );
   } catch (error) {
     // A stamp failure must not lose the freshly fetched quota.
     log.warn(`[quota] failed to stamp check outcome for account=${target.accountId}`, error as Error);

package/src/security/abuse.ts

@@ -113,6 +113,15 @@ export interface IpAbuseStore {
    * bounded `admission_unavailable` with zero dispatches.
    */
   checkAndRecord(attempt: IpAbuseAttempt): Promise<IpAbuseOutcome>;
+  /**
+   * Manually bans an identity for `durationMs` (0/negative = permanent).
+   * Throws when the store is unreachable.
+   */
+  ban(identity: string, durationMs: number): Promise<void>;
+  /** Lifts a manual (or any) ban on an identity. No-op when not banned. */
+  unban(identity: string): Promise<void>;
+  /** Lists currently active bans with their expiry (`null` = permanent). */
+  listBans(): Promise<readonly { identity: string; bannedUntil: number | null }[]>;
 }
 
 interface IpAbuseProtectionServiceOptions {
@@ -293,6 +302,34 @@ export class InMemoryIpAbuseStore implements IpAbuseStore {
     return true;
   }
 
+  async ban(identity: string, durationMs: number): Promise<void> {
+    this.assertAvailable();
+    this.evictOldest(this.bans);
+    this.bans.set(identity, durationMs > 0 ? this.clock() + durationMs : Number.POSITIVE_INFINITY);
+  }
+
+  async unban(identity: string): Promise<void> {
+    this.assertAvailable();
+    this.bans.delete(identity);
+  }
+
+  async listBans(): Promise<readonly { identity: string; bannedUntil: number | null }[]> {
+    this.assertAvailable();
+    const now = this.clock();
+    const out: { identity: string; bannedUntil: number | null }[] = [];
+    for (const [identity, until] of this.bans) {
+      if (until <= now) {
+        this.bans.delete(identity);
+        continue;
+      }
+      out.push({
+        identity,
+        bannedUntil: Number.isFinite(until) ? until : null,
+      });
+    }
+    return out;
+  }
+
   async checkAndRecord(attempt: IpAbuseAttempt): Promise<IpAbuseOutcome> {
     this.assertAvailable();
     const { identity, route, now, limit, banThreshold, banDurationMs } = attempt;
@@ -582,5 +619,39 @@ export class RedisIpAbuseStore implements IpAbuseStore {
     );
     return decodeAbuseOutcome(raw);
   }
+
+  async ban(identity: string, durationMs: number): Promise<void> {
+    const marker = this.banMarkerKey(identity);
+    const now = Date.now();
+    if (durationMs > 0) {
+      await this.redis.set(marker, String(now + durationMs), "PX", durationMs);
+    } else {
+      // Permanent: no TTL; a large sentinel far in the future.
+      await this.redis.set(marker, String(Number.MAX_SAFE_INTEGER));
+    }
+  }
+
+  async unban(identity: string): Promise<void> {
+    await this.redis.del(this.banMarkerKey(identity));
+  }
+
+  async listBans(): Promise<readonly { identity: string; bannedUntil: number | null }[]> {
+    const keys = await this.redis.keys("cartethyia:ip:ban:*");
+    const now = Date.now();
+    const out: { identity: string; bannedUntil: number | null }[] = [];
+    for (const key of keys) {
+      const value = await this.redis.get(key);
+      const until = Number(value ?? 0);
+      if (!Number.isFinite(until) || until <= now) {
+        await this.redis.del(key);
+        continue;
+      }
+      out.push({
+        identity: key.slice("cartethyia:ip:ban:".length),
+        bannedUntil: until >= Number.MAX_SAFE_INTEGER - 1 ? null : until,
+      });
+    }
+    return out;
+  }
 }
 

package/src/security/api-key-auth-cache.ts

@@ -1,7 +1,7 @@
 /** Bounded process-local authorization cache; shared-cache I/O stays in the auth service. */
 export const AUTH_CACHE_TTL_MS = 3_000;
 const AUTH_CACHE_MAX_ENTRIES = 10_000;
-const AUTH_NEGATIVE_CACHE_TTL_MS = 1_500;
+export const AUTH_NEGATIVE_CACHE_TTL_MS = 1_500;
 const AUTH_FAILURE_COOLDOWN_MS = 1_000;
 
 interface CacheEntry<T> {

package/src/security/api-key-auth.ts

@@ -21,8 +21,12 @@ import type { ApiKeyModelAccessMode } from "../persistence/schema";
  * snapshot's consumed value is a reference point, so a brief stale window
  * cannot meaningfully over-consume a budget.
  *
- * Negative results (unknown/revoked tokens) are deliberately NOT cached, so
- * a newly minted key is usable immediately.
+ * Unknown or revoked tokens are negative-cached for
+ * `AUTH_NEGATIVE_CACHE_TTL_MS` (1.5s): a token rejected within that window
+ * stays refused even if its key is minted or un-revoked in between. A newly
+ * minted key is usable immediately only because `invalidateApiKeyCache`
+ * clears the negative entries when a mutation lands — not because negatives
+ * are absent.
  */
 const authorizationCache = createApiKeyAuthorizationCache<ResolvedApiKey>();
 

package/src/transport/dispatch/attempt-finalize.ts

@@ -622,19 +622,20 @@ export function nativeCompletionBase(input: {
   | "tokensPerSec"
 > {
   return {
-    providerId: input.providerId,
-    modelId: input.modelId,
-    tenantId: input.tenantId,
-    ingressBody: input.ingressBody,
-    terminal: true,
-    ...(input.accountId === undefined ? {} : { accountId: input.accountId }),
-    ...(input.accountLabel === undefined ? {} : { accountLabel: input.accountLabel }),
-    ...(input.networkPoolId === undefined ? {} : { networkPoolId: input.networkPoolId }),
-    ...(input.lease === undefined ? {} : { lease: input.lease }),
-    db: input.db,
-    ...(input.telemetryBuffer === undefined ? {} : { telemetryBuffer: input.telemetryBuffer }),
-    ...(input.snapshotService === undefined ? {} : { snapshotService: input.snapshotService }),
-    ...(input.providerCapture === undefined ? {} : { providerCapture: input.providerCapture }),
+    ...completionContext({
+      providerId: input.providerId,
+      modelId: input.modelId,
+      tenantId: input.tenantId,
+      ingressBody: input.ingressBody,
+      ...(input.providerCapture === undefined ? {} : { providerCapture: input.providerCapture }),
+      db: input.db,
+      ...(input.accountId === undefined ? {} : { accountId: input.accountId }),
+      ...(input.accountLabel === undefined ? {} : { accountLabel: input.accountLabel }),
+      ...(input.networkPoolId === undefined ? {} : { networkPoolId: input.networkPoolId }),
+      ...(input.lease === undefined ? {} : { lease: input.lease }),
+      ...(input.telemetryBuffer === undefined ? {} : { telemetryBuffer: input.telemetryBuffer }),
+      ...(input.snapshotService === undefined ? {} : { snapshotService: input.snapshotService }),
+    }),
     ...(input.usage === undefined ? {} : { usage: input.usage }),
     ...(input.commitUsage === undefined ? {} : { commitUsage: input.commitUsage }),
   };

package/src/transport/dispatch/attempt-loop.ts

@@ -32,7 +32,7 @@ import { metrics } from "../../observability/metrics";
 import type { NetworkPoolSelector } from "../../network/pool/selector";
 import type { ProxyRequestState } from "../request/state";
 import type { TelemetryBatchBuffer } from "../../observability/telemetry-buffer";
-import { flagPoolBlocked, flagPoolCooldown } from "../../network/pool-health";
+import { flagPoolOnEgressFailure } from "../../network/pool-health";
 import {
   completeAttempt,
   errorClientResponseBody,
@@ -61,6 +61,41 @@ function comboCandidateKey(candidate: RouteCandidate): string {
   ].join(":");
 }
 
+/**
+ * Extra dials allowed for a mid-response upstream socket drop when the
+ * candidate list is exhausted (single-account providers). One extra dial
+ * recovers the transient reset; more would stack latency on a dying origin.
+ */
+const MAX_SOCKET_DROP_RETRIES = 1;
+
+/**
+ * Normalizes a raw (non-GatewayError) failure before it escapes the loop.
+ *
+ * A transport-level throw — e.g. Bun's `TypeError` with
+ * `code: "ECONNRESET"` when the upstream socket dies mid-response — carries a
+ * `.code` of its own. The error middleware reads that `.code` for Elysia
+ * built-in errors, so a raw socket drop leaked to the client as
+ * `{"code":"ECONNRESET","status":400}` with origin `cartethyia`: the wrong
+ * code, the wrong status, and the wrong blame. The classifier already knows
+ * what this is (`transport_unavailable`, 502, upstream) — materialize it as a
+ * real GatewayError so the client and the captured Client Response see the
+ * same stable envelope every other upstream transport failure gets.
+ */
+function normalizeEscapeError(error: unknown, signal: AbortSignal): unknown {
+  if (error instanceof GatewayError) return error;
+  const terminal = classifyTerminalOutcome(error, signal);
+  if (terminal.errorCategory === "transport_unavailable") {
+    return new GatewayError(
+      "transport_unavailable",
+      502,
+      "The upstream closed the connection mid-response (request {requestId}). Retry; if it keeps happening, the account or pool is unstable. The connection ghosted us — come back in a moment 👻",
+      {},
+      "upstream",
+    );
+  }
+  return error;
+}
+
 /**
  * True when the rejection is about the API key or the gateway's own policy,
  * not about the provider account that was dialled.
@@ -321,7 +356,7 @@ export async function runAttemptLoop<TResult, TAdapter>(
             status: terminal.status === "cancelled" ? "cancelled" : "failed",
           });
         }
-        throw lastError;
+        throw normalizeEscapeError(lastError, state.abortController.signal);
       }
     }
     let lease: AdmissionLease | undefined;
@@ -381,6 +416,13 @@ export async function runAttemptLoop<TResult, TAdapter>(
       // names the real cause.
       const drain = drainAbortReason(state.abortController.signal.reason);
       if (drain !== undefined) error = drain;
+      // Normalize a raw transport throw (e.g. Bun's `TypeError` with
+      // `code: "ECONNRESET"` when the upstream socket dies mid-response) into
+      // the stable `transport_unavailable`/502/upstream GatewayError **before**
+      // classification, so the telemetry row, the captured Client Response, and
+      // the escaped error all agree — and the raw `.code` never leaks to the
+      // client as a fake Elysia built-in code (see `normalizeEscapeError`).
+      error = normalizeEscapeError(error, state.abortController.signal);
       lastError = error;
       // A drain is a *server* close, not a client cancel: it must be recorded
       // as a failure with the shutdown code, and it is never retryable.
@@ -411,21 +453,33 @@ export async function runAttemptLoop<TResult, TAdapter>(
       // the pool excluded. Both flag helpers write the local entry
       // synchronously, so the ordering holds even though the Redis mirror is
       // fire-and-forget.
-      if (networkPoolId && deps.poolSelector && error instanceof GatewayError) {
-        if (rateLimitedPool) {
-          flagPoolCooldown(deps.poolSelector, deps.db, networkPoolId, candidate.provider_id, error);
-        } else if (blockedPool) {
-          // The address itself is refused, not the request: retire the egress
-          // so the next attempt leaves by a different one instead of retrying
-          // a proxy the upstream has already flagged.
-          flagPoolBlocked(deps.poolSelector, deps.db, networkPoolId, candidate.provider_id, error);
-        }
-      }
+      flagPoolOnEgressFailure(
+        deps.poolSelector,
+        deps.db,
+        networkPoolId,
+        candidate.provider_id,
+        error,
+        egressVerdict,
+      );
+      // A mid-response upstream socket drop (`transport_unavailable`) is the one
+      // retryable failure that receives an extra dial even when the candidate
+      // list is exhausted: an origin that closes the connection before the
+      // response is often transient (Trae's edge resets under concurrency),
+      // and the fresh dial recovers it — verified live 2026-11-09, 7/7
+      // recovered on the first retry. Without this, a single-account provider
+      // (the common case) tripped `index === candidates.length - 1` on the very
+      // first attempt and the client saw the raw socket error. The retry is
+      // bounded to one extra dial per request, never unbounded.
+      const memberAttempts = attemptsByMember.get(memberKey) ?? 0;
+      const socketDropRetryLeft =
+        terminal.errorCategory === "transport_unavailable" &&
+        !cancelled &&
+        memberAttempts < MAX_SOCKET_DROP_RETRIES;
       const terminalAttempt =
         cancelled ||
         isClientScopedRejection(error) ||
         !isRetryableFailure(error) ||
-        (index === candidates.length - 1 && !poolScopedFailure);
+        ((index === candidates.length - 1 && !poolScopedFailure) && !socketDropRetryLeft);
       // Track only the most recent fired exchange; the array this replaced
       // accumulated every attempt's capture until the loop returned.
       if (providerCapture.request !== null) lastFiredCapture = providerCapture;
@@ -474,7 +528,7 @@ export async function runAttemptLoop<TResult, TAdapter>(
       // A 403 can be a deterministic provider policy rejection, not an
       // invalid OAuth credential. Only the evidence-based classifier above
       // may trigger a refresh.
-      const candidateKey = `${candidate.provider_id}:${candidate.provider_account_id ?? "global"}:${candidate.model_id}:${candidate.endpoint}`;
+      const candidateKey = comboCandidateKey(candidate);
       const authInvalidated = isOAuthCredentialInvalidated(error);
       if (
         !cancelled &&
@@ -499,7 +553,7 @@ export async function runAttemptLoop<TResult, TAdapter>(
       }
       if (terminalAttempt) {
         metrics.proxy_requests_total.inc(1, { status: cancelled ? "cancelled" : "failed" });
-        throw error;
+        throw normalizeEscapeError(error, state.abortController.signal);
       }
       // A failed combo member stays flagged for this request. Move it behind
       // every candidate that has not failed yet, so the next attempt cannot
@@ -542,7 +596,7 @@ export async function runAttemptLoop<TResult, TAdapter>(
         // as the sleep's own error would leave `proxy_requests_total` missing
         // the request.
         metrics.proxy_requests_total.inc(1, { status: "cancelled" });
-        throw lastError;
+        throw normalizeEscapeError(lastError, state.abortController.signal);
       }
     }
   }
@@ -577,5 +631,5 @@ export async function runAttemptLoop<TResult, TAdapter>(
     }));
   }
   metrics.proxy_requests_total.inc(1, { status: "failed" });
-  throw lastError;
+  throw normalizeEscapeError(lastError, state.abortController.signal);
 }

package/src/transport/dispatch/generation.ts

@@ -27,6 +27,7 @@ import { completeAttempt, estimatedUsage, nativeCompletionBase } from "./attempt
 import { runAttemptLoop } from "./attempt-loop";
 import { captureProviderRateLimit } from "./ratelimit-capture";
 import {
+  forwardUpstreamResponse,
   hasScope,
   jsonResponse,
   networkFetchContext,
@@ -133,14 +134,7 @@ async function passThrough(
     responseBody: null,
   });
   metrics.proxy_requests_total.inc(1, { status: "completed" });
-  return new Response(upstream.body, {
-    status: upstream.status,
-    headers: {
-      "content-type": upstream.headers.get("content-type") ?? "text/event-stream",
-      "cache-control": "no-store",
-      "x-request-id": state.requestId,
-    },
-  });
+  return forwardUpstreamResponse(upstream, state.requestId, "text/event-stream");
 }
 
 /** Builds the handler for one generation surface. */

package/src/transport/dispatch/native-shared.ts

@@ -71,6 +71,31 @@ export function jsonResponse(payload: unknown, status: number, requestId: string
   });
 }
 
+/**
+ * Forwards an upstream response body verbatim with the shared native-response
+ * header set.
+ *
+ * The native handlers (System One, responses-compact, token-count,
+ * generation's passThrough) each spelled the same three headers by hand; the
+ * copies drifted at least once (generation's JSON builder lost `cache-control`).
+ * Status and body come from the upstream untouched; only the content-type
+ * default differs per route (SSE vs JSON) and is passed per call.
+ */
+export function forwardUpstreamResponse(
+  response: Response,
+  requestId: string,
+  defaultContentType = "application/json",
+): Response {
+  return new Response(response.body, {
+    status: response.status,
+    headers: {
+      "content-type": response.headers.get("content-type") ?? defaultContentType,
+      "cache-control": "no-store",
+      "x-request-id": requestId,
+    },
+  });
+}
+
 /**
  * Strips a thinking suffix (`model(high)`) from the model name and rebuilds
  * the body with the bare model when it changed. Returns the bare model and

package/src/transport/dispatch/proxy-request.ts

@@ -11,7 +11,7 @@ import { chatAdapter } from "../surface/chat/adapter";
 import { responsesAdapter } from "../surface/responses/adapter";
 import { messagesAdapter } from "../surface/messages/adapter";
 import { completionAdapter } from "../surface/completion";
-import { forwardedRequestHeaders, proxySuccessHeaders, buildUpstreamDispatchContext, reportedModelFrom } from "./upstream";
+import { forwardedRequestHeaders, proxySuccessHeaders, buildUpstreamDispatchContext, buildDispatchNetworkBindings, reportedModelFrom } from "./upstream";
 import { resolvePromptCacheKey } from "../../providers/operations/session-resolution";
 import {
   applyTenantPreferences,
@@ -21,18 +21,12 @@ import {
 import { metrics } from "../../observability/metrics";
 import { repriceUsage } from "../../providers/provider-usage";
 import {
-  captureProviderExchange,
   completeAttempt,
   completionContext,
   estimatedUsage,
   parseCapturedBody,
   terminalFailure,
 } from "./attempt-finalize";
-import {
-  providerCaptureMaxBytes,
-  resolveCaptureDepthForRequest,
-  shouldCaptureProviderBodyForRequest,
-} from "./capture-policy";
 import { runAttemptLoop } from "./attempt-loop";
 import { projectForRoute, routeCapabilitiesFor } from "../../protocol/translation/capabilities";
 import { dispatchStreamingAttempt } from "./streaming/stream";
@@ -263,45 +257,14 @@ export async function handleProviderProxyRequest(
         ...(conversationAffinity ? { conversationAffinity } : {}),
         ...(tenantSystemPromptText === undefined ? {} : { tenantSystemPrompt: tenantSystemPromptText }),
         ...(candidate.user_agent === undefined ? {} : { userAgent: candidate.user_agent }),
-        ...(deps.networkBindingFactory
-          ? {
-              outboundFetch: captureProviderExchange(
-                deps.networkBindingFactory.fetch(
-                  networkPoolId,
-                  prepared.authorization.snapshot.tenant_id,
-                ),
-                providerCapture,
-                await shouldCaptureProviderBodyForRequest(
-                  deps.db,
-                  prepared.authorization.snapshot.tenant_id,
-                  state,
-                ),
-                providerCaptureMaxBytes(
-                  await resolveCaptureDepthForRequest(
-                    deps.db,
-                    prepared.authorization.snapshot.tenant_id,
-                    state,
-                  ),
-                ),
-              ),
-            }
-          : {}),
-        ...(deps.networkBindingFactory
-          ? {
-              outboundAttachmentFetch: deps.networkBindingFactory.fetch(
-                networkPoolId,
-                prepared.authorization.snapshot.tenant_id,
-              ),
-            }
-          : {}),
-        ...(deps.networkBindingFactory
-          ? {
-              outboundHttp2: deps.networkBindingFactory.http2Bidi(
-                networkPoolId,
-                prepared.authorization.snapshot.tenant_id,
-              ),
-            }
-          : {}),
+        ...(providerCapture ? { providerCapture } : {}),
+        ...(await buildDispatchNetworkBindings({
+          deps,
+          networkPoolId,
+          tenantId: prepared.authorization.snapshot.tenant_id,
+          providerCapture,
+          state,
+        })),
         ...(leaseOwnership === undefined ? {} : { leaseOwnership }),
         ...(continuationScope === undefined ? {} : { continuationScope }),
       });

package/src/transport/dispatch/responses-compact.ts

@@ -4,6 +4,7 @@ import type { CodexCompactAdapter } from "../../providers/integrations/codex/cod
 import { completeAttempt, estimatedUsage, nativeCompletionBase } from "./attempt-finalize";
 import { runAttemptLoop } from "./attempt-loop";
 import {
+  forwardUpstreamResponse,
   networkFetchContext,
   requireRecordBody,
   resolveAttemptCredential,
@@ -143,14 +144,7 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
           responseBody: null,
         });
         metrics.proxy_requests_total.inc(1, { status: "completed" });
-        return new Response(response.body, {
-          status: response.status,
-          headers: {
-            "content-type": response.headers.get("content-type") ?? "application/json",
-            "cache-control": "no-store",
-            "x-request-id": state.requestId,
-          },
-        });
+        return forwardUpstreamResponse(response, state.requestId);
       },
     });
   };