@bitkyc08/opencodex 2.84.0 → 2.87.0

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

@@ -1,5 +1,6 @@
 import type { TranslatorBudget } from "../../lib/translator-budget";
 import { finalizeTranslatorBudgetResponse } from "../../lib/translator-budget";
+import { isNonReplayableResponse, markResponseNonReplayable } from "../../lib/upstream-retry";
 import {
   isNativePassthroughSseResponse,
   markNativePassthroughSseResponse,
@@ -47,11 +48,13 @@ export function finalizeOwnedTranslatorBudget(response: Response, budget: Transl
     markEagerRelaySseResponse(finalizedResponse);
   }
   if (isPreinspectedJsonResponse(response)) markPreinspectedJsonResponse(finalizedResponse);
+  if (isNonReplayableResponse(response)) markResponseNonReplayable(finalizedResponse);
+  if (runTurnAdapterSseResponses.has(response)) runTurnAdapterSseResponses.add(finalizedResponse);
   return finalizedResponse;
 }
 
 /** Release a serving-account slot when the client body ends, errors or is cancelled. */
-export function finalizeAccountLease(response: Response, release: () => void): Response {
+export function finalizeAccountLease(response: Response, release: () => void, onCancel?: () => void): Response {
   if (!response.body) { release(); return response; }
   const reader = response.body.getReader();
   let done = false;
@@ -64,12 +67,14 @@ export function finalizeAccountLease(response: Response, release: () => void): R
         else controller.enqueue(next.value);
       } catch (error) { finish(); controller.error(error); }
     },
-    async cancel(reason) { try { await reader.cancel(reason); } finally { finish(); } },
+    async cancel(reason) { onCancel?.(); try { await reader.cancel(reason); } finally { finish(); } },
   });
   const wrapped = new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+  if (isNonReplayableResponse(response)) markResponseNonReplayable(wrapped);
   if (isNativePassthroughSseResponse(response)) markNativePassthroughSseResponse(wrapped);
   if (isEagerRelaySseResponse(response)) markEagerRelaySseResponse(wrapped);
   if (isPreinspectedJsonResponse(response)) markPreinspectedJsonResponse(wrapped);
+  if (runTurnAdapterSseResponses.has(response)) runTurnAdapterSseResponses.add(wrapped);
   return wrapped;
 }
 

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

@@ -1,3 +1,4 @@
+import { effectiveAzureOutputBudget } from "../../adapters/azure";
 import { sanitizeLogMetadataString } from "../../lib/redact";
 import type { RouteResult } from "../../router";
 import type { InboundWire } from "../../providers/registry";
@@ -211,6 +212,16 @@ export async function applyFinalRouteRequestNormalization(args: {
   logCtx.model = virtualModel?.selectedModelId ?? route.modelId;
   logCtx.provider = route.providerName;
   logCtx.spendPoolId = route.providerName;
+  // Admission precedes adapter serialization. Reserve the same explicit output cap
+  // the final destination will send, and recompute from the caller on every fallback.
+  const rawBudget = parsed._rawBody && typeof parsed._rawBody === "object"
+    ? (parsed._rawBody as { max_output_tokens?: unknown }).max_output_tokens : undefined;
+  const outputBudget = effectiveAzureOutputBudget(route.provider,
+    route.provider.adapter === "azure" || route.provider.adapter === "azure-openai"
+      ? rawBudget : parsed.options.maxOutputTokens);
+  if (typeof outputBudget === "number" && outputBudget > 0) {
+    logCtx.spendOutputCeilingTokens = Math.trunc(outputBudget);
+  }
   logCtx.providerAdapter = route.provider.adapter;
   logCtx.routeDecision = route.routeDecision;
   logCtx.policyEligibility = route.policyEligibility;

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";
@@ -22,6 +23,8 @@ import type { RequestLogContext } from "../request-log";
 import type { UpstreamHostAdmissionLease } from "../../codex/upstream-host-health";
 import type { AccountLease } from "../../oauth/kiro-account-load";
 import type { PolicyRequestScope } from "./policy-request-scope";
+import type { OcxParsedRequest } from "../../types";
+import type { PolicyRequestEvidence } from "../../routing/evaluator";
 
 export interface ConsumedComboFailure {
   response: Response;
@@ -61,6 +64,32 @@ export interface ClientEncoderOption {
   stream: boolean;
   model: string;
   inputTokenFloor?: number;
+  /**
+   * `direct` when the request side also skipped the internal Responses body (the Antigravity
+   * direct lane), so the attempt's request path is traced as `[inbound, ir, upstream]`.
+   */
+  requestLane?: "bridge" | "direct";
+}
+
+/**
+ * The Antigravity direct lane (`protocols.rollout.antigravityDirect`). The ingress sends the core
+ * a Responses body that carries only the request settings; the conversation is decoded straight
+ * from the client body. Request preparation applies `decode` at the parse seam, reads routing
+ * evidence from `evidence`, and calls `restoreBridgeConversation` if the final route is not the
+ * one the lane was decided for, so every `_rawBody` reader of another adapter sees the full
+ * bridge body.
+ */
+export interface DirectRequestOption {
+  protocol: "chat" | "messages";
+  /** The concrete route the ingress decided the lane for. */
+  providerName: string;
+  modelId: string;
+  /** Policy-routing evidence from the client body; the settings-only body has no `input`. */
+  evidence: PolicyRequestEvidence;
+  /** The settings-only parse with the directly decoded conversation in place of its empty one. */
+  decode(base: OcxParsedRequest): OcxParsedRequest;
+  /** The bridge projection's conversation fields (`input`, `instructions`, `tools`). */
+  bridgeConversation(): Record<string, unknown>;
 }
 
 export interface HandleResponsesOptions {
@@ -137,8 +166,17 @@ export interface HandleResponsesOptions {
    * it. Omitted means a genuine Responses inbound.
    */
   inboundWire?: InboundWire;
+  /**
+   * Set by a translating ingress (Chat / Anthropic) when the client sent an explicit empty
+   * tool catalog. Those wires may defer tool delivery, so their translated body carries no
+   * readable catalog boundary; an explicit `[]` is still a deny-all declaration and the
+   * undeclared-tool guard enforces it. Absent catalogs and partial catalogs stay deferred.
+   */
+  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>[];
   /** 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. */
@@ -172,6 +210,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;
@@ -202,6 +242,15 @@ export interface HandleResponsesOptions {
    * rebuilds headers and carries the fact through this flag.
    */
   visionDescribeTerminal?: boolean;
+  /**
+   * Terminal advisor marker: true when the inbound request IS the advisor sidecar's own loopback
+   * consultation. The advisor planner then never plans a consultation — a depth cap of 1 that
+   * keeps Worker → Advisor → Advisor recursion impossible (same structure as
+   * {@linkcode visionDescribeTerminal}). The Chat surface detects the raw
+   * `x-opencodex-advisor-internal` header before its bridge rebuilds headers and carries the
+   * fact through this flag.
+   */
+  advisorInternal?: boolean;
   /**
    * Set only by the Chat and Messages ingresses when `protocols.rollout.directEncoders` is on and
    * the settled route is one non-Responses target. Adapter delivery then encodes the adapter
@@ -210,6 +259,8 @@ export interface HandleResponsesOptions {
    * returning a Responses body, which the ingress converts as before.
    */
   clientEncoder?: ClientEncoderOption;
+  /** Set only by the Chat or Messages ingress on an eligible Antigravity route; see {@link DirectRequestOption}. */
+  directRequest?: DirectRequestOption;
 }
 
 /** Values shared by the call, not a bag of mutable pipeline state. */

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

@@ -24,6 +24,7 @@ import {
   type NativeReasoningOwner,
   bindReasoningReplayScope,
   reasoningReplayServingIdentityChanged,
+  reasoningReplayServingIdentityChange,
   reasoningReplayItemStoreChanged,
   reasoningReplayOpaqueBlobRejectionMemoized,
 } from "../../responses/reasoning-replay-cache";
@@ -32,6 +33,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.
@@ -125,11 +127,13 @@ export function bindRouteReasoningReplayScope(args: {
   if (owner) parsed._nativeReasoningBoundOwner = owner;
   else delete parsed._nativeReasoningBoundOwner;
   if (parsed._nativeReasoningReplay?.size) {
+    const rejected = new Set<string>();
     for (const [blob, tag] of parsed._nativeReasoningReplay) {
       if (!nativeReasoningTagMatches(nativeReasoningTag(owner, blob), tag)) {
-        stripNativeReasoningBlob(parsed, blob);
+        rejected.add(blob);
       }
     }
+    if (rejected.size) stripNativeReasoningBlobs(parsed, rejected);
   }
   const continuationDestinationIdentity = providerContinuationDestinationIdentity(parsed, provider);
   const continuationOwner = providerContinuationOwnerFromReplayIdentity(
@@ -154,8 +158,19 @@ 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)) {
@@ -164,16 +179,19 @@ export function bindRouteReasoningReplayScope(args: {
   }
   if (reasoningReplayOpaqueBlobRejectionMemoized(parsed._reasoningReplayScope)) {
     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);
 }
 
-function stripNativeReasoningBlob(parsed: OcxParsedRequest, blob: string): void {
+function stripNativeReasoningBlobs(parsed: OcxParsedRequest, rejected: ReadonlySet<string>): void {
   const input = (parsed._rawBody as { input?: unknown } | undefined)?.input;
   if (Array.isArray(input)) {
     for (const item of input) {
-      if (item && typeof item === "object" && item.type === "reasoning" && item.encrypted_content === blob) {
+      if (item && typeof item === "object" && item.type === "reasoning" && rejected.has(item.encrypted_content)) {
         delete item.encrypted_content;
         delete item.id;
       }
@@ -187,7 +205,8 @@ function stripNativeReasoningBlob(parsed: OcxParsedRequest, blob: string): void
         const item: unknown = JSON.parse(part.signature);
         if (!item || typeof item !== "object" || Array.isArray(item)) continue;
         const reasoning = item as Record<string, unknown>;
-        if (reasoning.type !== "reasoning" || reasoning.encrypted_content !== blob) continue;
+        if (reasoning.type !== "reasoning" || typeof reasoning.encrypted_content !== "string"
+          || !rejected.has(reasoning.encrypted_content)) continue;
         delete reasoning.encrypted_content;
         delete reasoning.id;
         part.signature = JSON.stringify(reasoning);

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
@@ -48,7 +33,7 @@ export async function handleResponses(
   abortSignal.addEventListener("abort", cancel, { once: true });
   try {
     const response = await runWithCompactionRecovery(req, config, logCtx, {
-      ...options,
+      ...options, abortSignal,
       openAiSidecarAuth: options.openAiSidecarAuth === undefined
         ? captureExplicitOpenAiCallerAuth(req.headers, config) : options.openAiSidecarAuth,
       nativeCallerAuth: options.nativeCallerAuth === undefined
@@ -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 {