@bitkyc08/opencodex 2.86.0 → 2.88.0

package/src/server/responses/core-opaque-recovery.ts

@@ -276,6 +276,39 @@ export function isSelfIdentifiedOpaqueBlobRejection(bodyText: string): boolean {
 }
 
 
+/**
+ * Opted-in native reasoning retention forwards ciphertext another model or account minted. ChatGPT
+ * can refuse it inside a 200 stream -- a Codex WebSocket `error` frame or `response.failed` --
+ * rather than as an HTTP 4xx, so the passthrough inspects the zero-output prelude of exactly these
+ * requests. Ordinary turns keep the function-output-only inspection.
+ */
+export function retainedReasoningStreamCandidate(parsed: OcxParsedRequest, outboundBody: string | undefined): boolean {
+  return parsed._nativeReasoningRetainedAcrossRoute === true
+    && parsed._stripReasoningEncryptedContent !== true
+    && outboundResponsesBodyCarriesOpaqueBlob(outboundBody);
+}
+
+/**
+ * Whether a stream-prelude payload is a self-identified refusal of retained ciphertext. A match marks
+ * the projected failure as the 4xx it is, so the shared single-shot trigger accepts it.
+ */
+export function retainedReasoningStreamRejection(
+  payload: unknown,
+  parsed: OcxParsedRequest,
+  outboundBody: string | undefined,
+  preflightLog: RequestLogContext,
+): boolean {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return false;
+  if (!retainedReasoningStreamCandidate(parsed, outboundBody)) return false;
+  const { type, response } = payload as { type?: unknown; response?: { error?: unknown } };
+  if (type !== "error" && type !== "response.failed") return false;
+  const envelope = type === "error" ? payload : { error: response?.error };
+  if (!isSelfIdentifiedOpaqueBlobRejection(JSON.stringify(envelope))) return false;
+  preflightLog.terminalHttpStatus = 400;
+  return true;
+}
+
+
 /**
  * Whether an upstream Responses 4xx authoritatively rejected opaque replay state.
  *
@@ -411,6 +444,8 @@ export async function consoleGoUploadRejectionBody(
 
 export function prepareOpaqueBlobRecovery(parsed: OcxParsedRequest): void {
   parsed._stripReasoningEncryptedContent = true;
+  delete parsed._nativeReasoningRetainedAcrossRoute;
+  parsed._stripNativeCompactionEncryptedContent = true;
   // The destination rejected state another serving identity minted. A reasoning item's id names
   // an item in that identity's store, so it goes with the blob.
   parsed._dropForeignReasoningItemIds = true;

package/src/server/responses/core-options.ts

@@ -15,6 +15,7 @@ import type { InboundWire } from "../../providers/registry";
 import type { ExplicitOpenAiCallerAuth } from "../../providers/openai-sidecar";
 import type { CallerDirectAuth } from "../../providers/caller-authorization";
 import type { CompactionRoutingOverride } from "./compaction-routing";
+import type { MainHardLockFallbackOverride } from "./main-hard-lock-routing";
 import type { TranslatorBudget } from "../../lib/translator-budget";
 import type { NativeReasoningOwner } from "../../responses/reasoning-replay-cache";
 import type { TransientSendBudget } from "../../lib/upstream-retry";
@@ -174,6 +175,10 @@ export interface HandleResponsesOptions {
   clientDeclaredEmptyToolCatalog?: boolean;
   nativeReasoningReplay?: ReadonlyMap<string, string>;
   nativeReasoningMint?: { owner?: NativeReasoningOwner };
+  /** The Claude client's typed `web_search_*` / `web_fetch_*` declarations; kept only for `inboundWire: "anthropic"`. */
+  anthropicServerTools?: readonly Record<string, unknown>[];
+  /** The Claude client's replayable server-tool exchanges (`replayedAnthropicServerBlocks`); same scope. */
+  anthropicServerReplay?: ReadonlyMap<string, readonly Record<string, unknown>[]>;
   /** Droid's per-request effort default; each concrete combo or policy target applies it only if its ladder allows it. */
   droidDefaultEffort?: string;
   /** PF-07: the Chat source a combo child may send natively; set only by the Chat ingress. */
@@ -207,6 +212,8 @@ export interface HandleResponsesOptions {
   /** Internal handoff: the memory phase this turn belongs to, so combo children keep its routing. */
   memoryModelPhase?: "extract" | "consolidation";
   compactionRoutingOverride?: CompactionRoutingOverride | null;
+  /** Internal handoff: the hard-lock fallback rewrote this turn; the log shows `sourceModel`. */
+  mainHardLockFallbackOverride?: MainHardLockFallbackOverride | null;
   /** Internal combo handoff for one parent-validated continuation snapshot. */
   comboReplaySnapshot?: {
     sourceBody: unknown;

package/src/server/responses/core-pipeline.ts

@@ -0,0 +1,141 @@
+import { supportsNativeResponsesCompactionTrigger } from "../../providers/openai-tiers";
+import type { OcxConfig } from "../../types";
+import type { RequestLogContext } from "../request-log";
+import type {
+  HandleResponsesOptions,
+  ResponsesRequestContext,
+  ResponsesAdmissionState,
+  ResponsesDispatchers,
+} from "./core-options";
+import type { TranslatorBudget } from "../../lib/translator-budget";
+import { prepareResponsesRequest } from "./request-prepare";
+import { prepareResponsesTransport } from "./request-transport";
+import { prepareResponsesSidecarAuth } from "./request-sidecar-auth";
+import { createResponsesEffects } from "./response-effects";
+import { createResponsesSendBudget } from "./request-send-budget";
+import { executePassthroughResponse } from "./passthrough-execution";
+import { executeResponsesSidecars } from "./sidecar-execution";
+import { createResponsesCompletionPolicy } from "./completion-policy";
+import { executeResponsesRunTurn } from "./run-turn-execution";
+import { prepareAdapterExchange } from "./adapter-dispatch";
+import { createAdapterContinuations } from "./adapter-continuation";
+import { deliverAdapterResponse } from "./adapter-delivery";
+import { releaseUpstreamHostAdmission } from "../../codex/upstream-host-health";
+import { releaseCodexAuthContextProbeLease } from "../../codex/auth-context";
+import { formatErrorResponse } from "../../bridge";
+import { InvalidRetainedCompactionSummary, prepareCompactionRetention } from "./compaction-retention";
+
+/** Compose request phases while retaining the original admission-finally ownership. */
+export async function handleResponsesInner(
+  req: Request,
+  config: OcxConfig,
+  logCtx: RequestLogContext,
+  options: HandleResponsesOptions & { translatorBudget: TranslatorBudget },
+  requestDispatchers: ResponsesDispatchers,
+): Promise<Response> {
+  const requestContext: ResponsesRequestContext = { req, config, logCtx, options };
+  const admissionState: ResponsesAdmissionState = {
+    pendingHostAdmissionLease: null,
+    authCtx: { kind: "main", accountId: null },
+  };
+  let retention: ReturnType<typeof prepareCompactionRetention>;
+  let releasePendingSend = () => {};
+  try {
+    const requestState = await prepareResponsesRequest(requestContext, admissionState, requestDispatchers);
+    if (requestState instanceof Response) return requestState;
+    const transportState = await prepareResponsesTransport(requestContext, admissionState, requestState);
+    if (transportState instanceof Response) return transportState;
+    options.onCompactionRecoveryRoute?.(requestState.route);
+    if (requestState.parsed._compactionRequest && options.compactionRecoveryKind !== "compaction-v1"
+      && (requestState.parsed._portableCompaction || !supportsNativeResponsesCompactionTrigger(requestState.route.provider))) {
+      retention = prepareCompactionRetention(requestState.parsed, config,
+        requestState.route.staticPolicy.model.contextWindow ?? requestState.route.staticPolicy.model.maxInputTokens,
+        options.translatorBudget, options.abortSignal ?? req.signal);
+    }
+    const execute = async (): Promise<Response> => {
+      const sidecarState = await prepareResponsesSidecarAuth(requestContext, requestState, transportState);
+      if (sidecarState instanceof Response) return sidecarState;
+      const responseEffects = createResponsesEffects(
+        requestContext,
+        admissionState,
+        requestState,
+        sidecarState,
+      );
+      const sendBudgetState = createResponsesSendBudget(requestContext);
+      if (sendBudgetState instanceof Response) return sendBudgetState;
+      if ("passthrough" in transportState.adapter && transportState.adapter.passthrough && !sidecarState.routedCompaction) {
+        const passthroughResult = await executePassthroughResponse(
+          requestContext,
+          admissionState,
+          requestState,
+          transportState,
+          sidecarState,
+          responseEffects,
+          sendBudgetState,
+        );
+        if (passthroughResult instanceof Response) return passthroughResult;
+        const unclaimedHop = sendBudgetState.pendingHopPermit;
+        releasePendingSend = () => { if (sendBudgetState.pendingHopPermit === unclaimedHop) { unclaimedHop?.release(); sendBudgetState.pendingHopPermit = undefined; } };
+      }
+      const sidecarPlans = await executeResponsesSidecars(
+        requestContext,
+        requestState,
+        transportState,
+        sidecarState,
+        responseEffects,
+        sendBudgetState,
+      );
+      if (sidecarPlans instanceof Response) return sidecarPlans;
+      const completionPolicy = createResponsesCompletionPolicy(requestContext, sidecarState);
+      if (transportState.adapter.runTurn) return await executeResponsesRunTurn(
+        requestContext,
+        admissionState,
+        requestState,
+        transportState,
+        sidecarState,
+        responseEffects,
+        sendBudgetState,
+        completionPolicy,
+      );
+      const adapterExchange = await prepareAdapterExchange(
+        requestContext,
+        admissionState,
+        requestState,
+        transportState,
+        responseEffects,
+        sendBudgetState,
+      );
+      if (adapterExchange instanceof Response) return adapterExchange;
+      const continuationState = createAdapterContinuations(
+        requestContext,
+        requestState,
+        transportState,
+        sidecarState,
+        sendBudgetState,
+        adapterExchange,
+      );
+      return await deliverAdapterResponse(
+        requestContext,
+        requestState,
+        transportState,
+        sidecarState,
+        responseEffects,
+        completionPolicy,
+        adapterExchange,
+        continuationState,
+      );
+    };
+    const response = await execute();
+    return retention ? retention.deliver(response) : response;
+  } catch (error) {
+    retention?.dispose();
+    if (error instanceof InvalidRetainedCompactionSummary) return formatErrorResponse(502, "invalid_compaction_summary", error.message);
+    throw error;
+  } finally {
+    releasePendingSend();
+    if (admissionState.pendingHostAdmissionLease) {
+      releaseUpstreamHostAdmission(admissionState.pendingHostAdmissionLease);
+      releaseCodexAuthContextProbeLease(admissionState.authCtx);
+    }
+  }
+}

package/src/server/responses/core-replay.ts

@@ -1,3 +1,5 @@
+import { bindAnthropicRejectionPolicy } from "../../adapters/anthropic-rejection-memo";
+import { getReasoningReplayOpaqueBlobRejection } from "../../responses/reasoning-replay-cache";
 import type {
   OcxProviderContinuationOwner,
   OcxProviderContinuationState,
@@ -24,6 +26,7 @@ import {
   type NativeReasoningOwner,
   bindReasoningReplayScope,
   reasoningReplayServingIdentityChanged,
+  reasoningReplayServingIdentityChange,
   reasoningReplayItemStoreChanged,
   reasoningReplayOpaqueBlobRejectionMemoized,
 } from "../../responses/reasoning-replay-cache";
@@ -32,6 +35,7 @@ import type { CodexAuthContext } from "../../codex/auth-context";
 import { thoughtSignatureReplaySalt } from "../../responses/thought-signature-replay";
 import { randomUUID } from "node:crypto";
 import { requiresPlaintextReasoningReplay } from "../../adapters/openai-responses/passthrough";
+import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers";
 
 /**
  * Adapters whose continuation state must survive Codex's store:false requests.
@@ -156,18 +160,34 @@ export function bindRouteReasoningReplayScope(args: {
   );
   // Keep this sticky for the whole outbound request: a later auth/key rebind may compare equal
   // after the first mismatch, but it cannot make history minted by the prior route decodable.
-  if (reasoningReplayServingIdentityChanged(parsed._reasoningReplayScope)) {
-    parsed._stripReasoningEncryptedContent = true;
+  const identityChange = reasoningReplayServingIdentityChange(parsed._reasoningReplayScope);
+  if (identityChange) {
+    // Reasoning retention does not establish portability of native compacted history.
+    parsed._stripNativeCompactionEncryptedContent = true;
+    const retention = parsed._nativeReasoningRetention;
+    const mayRetainReasoning = isCanonicalOpenAiForwardProvider(provider)
+      && !identityChange.providerChanged
+      && !identityChange.destinationChanged
+      && !identityChange.adapterChanged
+      && (!identityChange.modelChanged || retention?.modelSwitch === true)
+      && (!identityChange.credentialChanged || retention?.accountSwitch === true);
+    if (!mayRetainReasoning) parsed._stripReasoningEncryptedContent = true;
+    else if (parsed._stripReasoningEncryptedContent !== true) parsed._nativeReasoningRetainedAcrossRoute = true;
     // Only a different destination or credential makes the replayed item ids unresolvable; a
     // model change on the same store keeps them.
     if (reasoningReplayItemStoreChanged(parsed._reasoningReplayScope)) {
       parsed._dropForeignReasoningItemIds = true;
     }
   }
+  const rejectionMemo = getReasoningReplayOpaqueBlobRejection(parsed._reasoningReplayScope);
+  bindAnthropicRejectionPolicy(parsed, adapterName === "anthropic" ? rejectionMemo : undefined);
   if (reasoningReplayOpaqueBlobRejectionMemoized(parsed._reasoningReplayScope)) {
-    parsed._stripReasoningEncryptedContent = true;
+    if (adapterName !== "anthropic" || rejectionMemo?.mode !== "selective") parsed._stripReasoningEncryptedContent = true;
+    parsed._stripNativeCompactionEncryptedContent = true;
     parsed._dropForeignReasoningItemIds = true;
   }
+  // Stripping is authoritative: nothing retained remains to be refused.
+  if (parsed._stripReasoningEncryptedContent === true) delete parsed._nativeReasoningRetainedAcrossRoute;
   bindProviderContinuationForRoute(parsed, continuationOwner);
 }
 

package/src/server/responses/core.ts

@@ -1,9 +1,8 @@
+import { handleResponsesInner } from "./core-pipeline";
 import type { OcxConfig } from "../../types";
 import type { RequestLogContext } from "../request-log";
 import type {
   HandleResponsesOptions,
-  ResponsesRequestContext,
-  ResponsesAdmissionState,
   ResponsesDispatchers,
 } from "./core-options";
 import { createTranslatorBudget } from "../../lib/translator-budget";
@@ -13,20 +12,6 @@ import { createInferenceSendBudget } from "../inference/context";
 import { finalizeOwnedTranslatorBudget, finalizeAccountLease } from "./core-lifetime";
 import type { TranslatorBudget } from "../../lib/translator-budget";
 import { executeComboResponses } from "./core-combo";
-import { prepareResponsesRequest } from "./request-prepare";
-import { prepareResponsesTransport } from "./request-transport";
-import { prepareResponsesSidecarAuth } from "./request-sidecar-auth";
-import { createResponsesEffects } from "./response-effects";
-import { createResponsesSendBudget } from "./request-send-budget";
-import { executePassthroughResponse } from "./passthrough-execution";
-import { executeResponsesSidecars } from "./sidecar-execution";
-import { createResponsesCompletionPolicy } from "./completion-policy";
-import { executeResponsesRunTurn } from "./run-turn-execution";
-import { prepareAdapterExchange } from "./adapter-dispatch";
-import { createAdapterContinuations } from "./adapter-continuation";
-import { deliverAdapterResponse } from "./adapter-delivery";
-import { releaseUpstreamHostAdmission } from "../../codex/upstream-host-health";
-import { releaseCodexAuthContextProbeLease } from "../../codex/auth-context";
 import { runWithCompactionRecovery } from "./compaction-recovery";
 /**
  * Route one `/v1/responses` request through the adapter pipeline: recovery loop, passthrough
@@ -62,7 +47,7 @@ export async function handleResponses(
       accountLoad,
       // Once at ingress, spend observer included: a combo child inherits the parent's holder.
       sendBudget: options.sendBudget ?? createInferenceSendBudget(req, logCtx),
-    }, handleResponsesInner);
+    }, (req, config, logCtx, options) => handleResponsesInner(req, config, logCtx, options, requestDispatchers));
     const finalResponse = ownsBudget ? finalizeOwnedTranslatorBudget(response, translatorBudget, abortSignal) : response;
     if (!accountLoad.lease) { release(); return finalResponse; }
     return finalizeAccountLease(finalResponse, release);
@@ -92,104 +77,6 @@ export async function handleComboResponses(
     requestDispatchers,
   );
 }
-/** Compose request phases while retaining the original admission-finally ownership. */
-async function handleResponsesInner(
-  req: Request,
-  config: OcxConfig,
-  logCtx: RequestLogContext,
-  options: HandleResponsesOptions & { translatorBudget: TranslatorBudget },
-): Promise<Response> {
-  const requestContext: ResponsesRequestContext = { req, config, logCtx, options };
-  const admissionState: ResponsesAdmissionState = {
-    pendingHostAdmissionLease: null,
-    authCtx: { kind: "main", accountId: null },
-  };
-  let releasePendingSend = () => {};
-  try {
-    const requestState = await prepareResponsesRequest(requestContext, admissionState, requestDispatchers);
-    if (requestState instanceof Response) return requestState;
-    const transportState = await prepareResponsesTransport(requestContext, admissionState, requestState);
-    if (transportState instanceof Response) return transportState;
-    options.onCompactionRecoveryRoute?.(requestState.route);
-    const sidecarState = await prepareResponsesSidecarAuth(requestContext, requestState, transportState);
-    if (sidecarState instanceof Response) return sidecarState;
-    const responseEffects = createResponsesEffects(
-      requestContext,
-      admissionState,
-      requestState,
-      sidecarState,
-    );
-    const sendBudgetState = createResponsesSendBudget(requestContext);
-    if (sendBudgetState instanceof Response) return sendBudgetState;
-    if ("passthrough" in transportState.adapter && transportState.adapter.passthrough && !sidecarState.routedCompaction) {
-      const passthroughResult = await executePassthroughResponse(
-        requestContext,
-        admissionState,
-        requestState,
-        transportState,
-        sidecarState,
-        responseEffects,
-        sendBudgetState,
-      );
-      if (passthroughResult instanceof Response) return passthroughResult;
-      const unclaimedHop = sendBudgetState.pendingHopPermit;
-      releasePendingSend = () => { if (sendBudgetState.pendingHopPermit === unclaimedHop) { unclaimedHop?.release(); sendBudgetState.pendingHopPermit = undefined; } };
-    }
-    const sidecarPlans = await executeResponsesSidecars(
-      requestContext,
-      requestState,
-      transportState,
-      sidecarState,
-      responseEffects,
-      sendBudgetState,
-    );
-    if (sidecarPlans instanceof Response) return sidecarPlans;
-    const completionPolicy = createResponsesCompletionPolicy(requestContext, sidecarState);
-    if (transportState.adapter.runTurn) return await executeResponsesRunTurn(
-      requestContext,
-      admissionState,
-      requestState,
-      transportState,
-      sidecarState,
-      responseEffects,
-      sendBudgetState,
-      completionPolicy,
-    );
-    const adapterExchange = await prepareAdapterExchange(
-      requestContext,
-      admissionState,
-      requestState,
-      transportState,
-      responseEffects,
-      sendBudgetState,
-    );
-    if (adapterExchange instanceof Response) return adapterExchange;
-    const continuationState = createAdapterContinuations(
-      requestContext,
-      requestState,
-      transportState,
-      sidecarState,
-      sendBudgetState,
-      adapterExchange,
-    );
-    return await deliverAdapterResponse(
-      requestContext,
-      requestState,
-      transportState,
-      sidecarState,
-      responseEffects,
-      completionPolicy,
-      adapterExchange,
-      continuationState,
-    );
-  } finally {
-    releasePendingSend();
-    if (admissionState.pendingHostAdmissionLease) {
-      releaseUpstreamHostAdmission(admissionState.pendingHostAdmissionLease);
-      releaseCodexAuthContextProbeLease(admissionState.authCtx);
-    }
-  }
-}
 const requestDispatchers: ResponsesDispatchers = { handleResponses, handleComboResponses };
 export { adapterNeedsForcedContinuation } from "./core-replay";
 export {

package/src/server/responses/fetch-helpers.ts

@@ -12,6 +12,7 @@ import type { WsData } from "../ws-bridge";
 import {
   requestPacingMaxConcurrentRequests,
   sendTrackingRequestSlot,
+  trackProviderRequestSlotBody,
   waitForProviderRequestSlot,
   type ProviderRequestSlot,
 } from "../../providers/request-pacing";
@@ -49,6 +50,9 @@ const UPSTREAM_REWRITTEN = Symbol.for("opencodex.plugins.upstream-rewritten");
 const PHYSICAL_DISPATCH = Symbol.for("opencodex.physical-dispatch");
 // One WS attempt and its HTTP fallback are one logical physical-send receipt.
 const WS_FALLBACK_RECEIPT = Symbol.for("opencodex.ws-fallback-receipt");
+// Replacement admission waits on the client signal, outside the response-header deadline.
+const HEADER_DEADLINE = Symbol("header-deadline");
+type HeaderDeadline = { clientSignal: AbortSignal; pause(): void; resume(): void };
 
 /**
  * Announce once, per provider, that an explicit egress route moved this provider off the
@@ -139,6 +143,7 @@ export function wantsFreshConnection(
 export interface PaceAwareFetch {
   waitForPacing?: (signal?: AbortSignal) => Promise<ProviderRequestSlot | undefined>;
   unpacedFetch?: typeof globalThis.fetch;
+  fetchWithPacingSlot?: (slot: ProviderRequestSlot | undefined, input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) => Promise<Response>;
 }
 
 export type ProviderFetch = typeof globalThis.fetch & PaceAwareFetch;
@@ -252,7 +257,8 @@ export interface ProviderFetchOptions {
    */
   preOutputRefusalHold?: CodexWsPreOutputRefusalHold;
   /** Revalidate/rebuild a queued request at its physical send boundary, after pacing. */
-  dispatchOverride?: (input: Parameters<typeof globalThis.fetch>[0], init: RequestInit, execute: typeof globalThis.fetch) => Promise<Response>;
+  dispatchOverride?: (input: Parameters<typeof globalThis.fetch>[0], init: RequestInit, execute: typeof globalThis.fetch,
+    reacquirePacing?: (provider: OcxProviderConfig, modelId?: string) => Promise<void>) => Promise<Response>;
 }
 
 /** Compose provider pacing and transport admission; receipts run only at executor entry. */
@@ -301,7 +307,8 @@ export function providerFetch(
     { preconnect },
   ) as typeof globalThis.fetch);
   const httpFetch = Object.assign(
-    async (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) => {
+    async (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit,
+      reacquirePacing?: (provider: OcxProviderConfig, modelId?: string) => Promise<void>) => {
       // Refuse before any dispatch side effect where that is sound. `beforeDispatch` commits
       // attempt accounting and consumes admission state, so a refusal firing after it would
       // charge an attempt for a send that never happens, and a throwing hook would mask the
@@ -329,30 +336,33 @@ export function providerFetch(
         } } : {}),
       };
       return options.dispatchOverride
-        ? options.dispatchOverride(input, dispatchInit, dispatch)
+        ? options.dispatchOverride(input, dispatchInit, dispatch, reacquirePacing)
         : dispatch(input, dispatchInit);
     },
     { preconnect },
-  ) as typeof globalThis.fetch;
+  );
   // ChatGPT Codex backend: streaming turns ride the responses_websockets
   // transport (measured ~3s faster TTFT than the SSE POST queue); everything
   // else keeps the provider's HTTP fetch. See ws-upstream.ts for the details.
-  const unpaced = async (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) => {
+  const unpaced = async (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit,
+    reacquirePacing?: (provider: OcxProviderConfig, modelId?: string) => Promise<void>) => {
     const upstreamWebsocket = provider.upstreamWebsocket;
     if (!options.httpOnly && typeof input === "string" && init
       && shouldUseCodexWsUpstream(input, init, runtime, upstreamWebsocket)) {
-      if (options.providerName && requestPacingMaxConcurrentRequests(provider, options.modelId) > 0) {
+      const keyedPacing = provider.requestPacing?.enabled
+        && (provider.requestPacing.keys || provider.requestPacing.keySelection === "round-robin");
+      if (keyedPacing || (options.providerName && requestPacingMaxConcurrentRequests(provider, options.modelId) > 0)) {
         if (!pacingWebsocketDowngradeWarned.has(providerName)
           && pacingWebsocketDowngradeWarned.size < EGRESS_DOWNGRADE_NOTICE_LIMIT) {
           pacingWebsocketDowngradeWarned.add(providerName);
-          console.warn(`[opencodex] provider ${JSON.stringify(redactSecretString(providerName))} has a request concurrency cap; serving over HTTP/SSE.`);
+          console.warn(`[opencodex] provider ${JSON.stringify(redactSecretString(providerName))} requires guarded request pacing; serving over HTTP/SSE.`);
         }
-        return httpFetch(input, init);
+        return httpFetch(input, init, reacquirePacing);
       }
       const egress = egressFor(input);
       if (providerEgressIsExplicit(egress)) {
         warnEgressWebsocketDowngradeOnce(providerName, describeProviderEgressForLog(egress));
-        return httpFetch(input, init);
+        return httpFetch(input, init, reacquirePacing);
       }
       // The fallback has to be the same HTTP fetch the non-WS branch would have
       // used, protocol pin included: a WS turn that falls back is serving the
@@ -365,11 +375,11 @@ export function providerFetch(
         options.onPhysicalDispatch?.();
       };
       const fallback = ((url: Parameters<typeof globalThis.fetch>[0], fallbackInit?: RequestInit) =>
-        httpFetch(url, { ...fallbackInit, [WS_FALLBACK_RECEIPT]: notifyOnce } as RequestInit)) as typeof globalThis.fetch;
+        httpFetch(url, { ...fallbackInit, [WS_FALLBACK_RECEIPT]: notifyOnce } as RequestInit, reacquirePacing)) as typeof globalThis.fetch;
       return codexWsUpstreamFetch(input, init, fallback, runtime, options.onCodexWsQuota, options.beforeDispatch, options.nativeControl,
         async () => { (await waitForPacing(init.signal ?? undefined))?.release(); }, notifyOnce, options.preOutputRefusalHold);
     }
-    return httpFetch(input, init);
+    return httpFetch(input, init, reacquirePacing);
   };
   let pacingSlotAcquired = options.pacingSlotAcquired === true;
   const waitForPacing = async (signal?: AbortSignal): Promise<ProviderRequestSlot | undefined> => {
@@ -392,15 +402,35 @@ export function providerFetch(
       throw new Error("A provider name is required for request concurrency pacing");
     }
   };
-  const wrapped = async (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) => {
-    return sendTrackingRequestSlot(await waitForPacing(init?.signal ?? undefined), () => unpaced(input, init));
+  const fetchWithPacingSlot = async (slot: ProviderRequestSlot | undefined, input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) => {
+    const reacquirePacing = async (refreshed: OcxProviderConfig, modelId?: string) => {
+      if (options.turnScopedPacing) throw new Error("Cannot replace a turn-scoped pacing lease during dispatch");
+      if (!options.providerName) throw new Error("Refreshed dispatch requires a named pacing owner");
+      slot?.release();
+      slot = undefined;
+      const deadline = (init as Record<symbol, HeaderDeadline> | undefined)?.[HEADER_DEADLINE];
+      deadline?.pause();
+      try {
+        slot = await waitForProviderRequestSlot(providerName, refreshed, modelId, deadline?.clientSignal ?? init?.signal ?? undefined);
+      } finally { deadline?.resume(); }
+    };
+    try {
+      const response = await unpaced(input, init, reacquirePacing);
+      return trackProviderRequestSlotBody(slot, response);
+    } catch (error) {
+      slot?.release();
+      throw error;
+    }
   };
+  const wrapped = async (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) =>
+    fetchWithPacingSlot(await waitForPacing(init?.signal ?? undefined), input, init);
   // The returned wrapper forwards its init down to `dispatch`, which applies the route at the
   // physical send. Adapters that hand this executor back as `provider.fetch` (Cursor does)
   // therefore still carry a per-provider route instead of being refused as opaque.
   const paceAware = Object.assign(wrapped, {
     preconnect,
     waitForPacing,
+    fetchWithPacingSlot,
     unpacedFetch: Object.assign(unpaced, { preconnect }),
   });
   markEgressTransparentExecutor(paceAware as unknown as typeof globalThis.fetch);
@@ -432,6 +462,9 @@ export function storedPoolReplayDispatchNotifier(
     notified = true;
     onDispatch();
   };
+  const notifyWithSlot = (slot: ProviderRequestSlot | undefined): void => {
+    try { notifyOnce(); } catch (error) { slot?.release(); throw error; }
+  };
   const unpacedSource = executor.unpacedFetch ?? executor;
   const unpaced = Object.assign(
     (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) => {
@@ -441,12 +474,21 @@ export function storedPoolReplayDispatchNotifier(
     { preconnect: unpacedSource.preconnect },
   ) as ProviderFetch["unpacedFetch"];
   const wrapped = async (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) => {
+    if (executor.fetchWithPacingSlot) {
+      const slot = await executor.waitForPacing?.(init?.signal ?? undefined);
+      notifyWithSlot(slot);
+      return executor.fetchWithPacingSlot(slot, input, init);
+    }
     return sendTrackingRequestSlot(await executor.waitForPacing?.(init?.signal ?? undefined), () => unpaced!(input, init));
   };
   return Object.assign(wrapped, {
     preconnect: executor.preconnect,
     waitForPacing: executor.waitForPacing,
     unpacedFetch: unpaced,
+    ...(executor.fetchWithPacingSlot ? { fetchWithPacingSlot: (slot: ProviderRequestSlot | undefined, input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) => {
+      notifyWithSlot(slot);
+      return executor.fetchWithPacingSlot!(slot, input, init);
+    } } : {}),
   }) as ProviderFetch;
 }
 
@@ -470,24 +512,36 @@ export async function fetchWithHeaderTimeout(
   let timer: ReturnType<typeof setTimeout> | undefined;
   try {
     const timeout = new AbortController();
-    timer = setTimeout(() => {
-      if (!timeout.signal.aborted) timeout.abort(new DOMException("Timeout elapsed", "TimeoutError"));
-    }, timeoutMs);
+    const deadline: HeaderDeadline = {
+      clientSignal: abortSignal,
+      pause() { if (timer) clearTimeout(timer); timer = undefined; },
+      resume() {
+        this.pause();
+        timer = setTimeout(() => {
+          if (!timeout.signal.aborted) timeout.abort(new DOMException("Timeout elapsed", "TimeoutError"));
+        }, timeoutMs);
+      },
+    };
+    deadline.resume();
     const headers = new Headers(init.headers);
     // Compressed SSE can be held until the decompressor has a complete block. Streaming calls
     // default to identity for low-latency frame delivery, while an explicit caller choice wins.
     if (preferIdentityEncoding && !headers.has("accept-encoding")) {
       headers.set("accept-encoding", "identity");
     }
-    return await sendTrackingRequestSlot(slot, () => fetchExecutor(url, {
+    const dispatchInit = {
       ...init,
       headers,
       // Never replay provider credentials or request bodies to a redirect destination.
       // Preserve the 3xx for the owner's existing response/health policy (#914, #1471).
-      redirect: "manual",
+      redirect: "manual" as const,
       signal: AbortSignal.any([abortSignal, timeout.signal]),
+      [HEADER_DEADLINE]: deadline,
       timeout: 0,
-    }));
+    };
+    return pacing.fetchWithPacingSlot
+      ? await pacing.fetchWithPacingSlot(slot, url, dispatchInit)
+      : await sendTrackingRequestSlot(slot, () => fetchExecutor(url, dispatchInit));
   } finally {
     if (timer) clearTimeout(timer);
     if (!slot?.bodyTracked) slot?.release();