@bitkyc08/opencodex 2.81.0 → 2.82.0

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

@@ -43,6 +43,10 @@ const pacingWebsocketDowngradeWarned = new Set<string>();
  */
 const EGRESS_DECIDED = Symbol.for("opencodex.provider-egress.decided");
 const UPSTREAM_REWRITTEN = Symbol.for("opencodex.plugins.upstream-rewritten");
+// Survives queued credential rebuilds and executor replacement without importing budget owners.
+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");
 
 /**
  * Announce once, per provider, that an explicit egress route moved this provider off the
@@ -200,6 +204,7 @@ export function sendWithConnectionPolicy(
   const largeCodexBody = typeof body === "string"
     && /^https:\/\/chatgpt\.com\/backend-api\/codex\/responses(?:\/compact)?$/.test(target)
     && Buffer.byteLength(body, "utf8") >= 1024 * 1024;
+  (init as Record<symbol, (() => void) | undefined> | undefined)?.[PHYSICAL_DISPATCH]?.();
   return physicalFetch(input, {
     ...init,
     ...(largeCodexBody ? { body: Buffer.from(body, "utf8") } : {}),
@@ -233,10 +238,13 @@ export interface ProviderFetchOptions {
   onCodexWsQuota?: CodexWsQuotaObserver;
   /** Synchronous admission at actual credential dispatch, after pacing/backoff. */
   beforeDispatch?: (headers: Headers) => void;
+  /** One-shot receipt after final local HTTP admission, immediately before executor entry. */
+  onPhysicalDispatch?: () => void;
   /** 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>;
 }
 
+/** Compose provider pacing and transport admission; receipts run only at executor entry. */
 export function providerFetch(
   provider: OcxProviderConfig,
   runtime: BunRuntimeGateInput = currentBunRuntimeIdentity(),
@@ -301,7 +309,14 @@ export function providerFetch(
       options.beforeDispatch?.(new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined)));
       // No proxy option is attached here: a `dispatchOverride` may rebuild this request against
       // a different destination, so the route is decided at the physical send instead.
-      const dispatchInit = { ...withUpstreamHttpVersion(input, init, provider), timeout: 0 };
+      const sharedReceipt = (init as Record<symbol, (() => void) | undefined> | undefined)?.[WS_FALLBACK_RECEIPT];
+      let notified = false;
+      const dispatchInit = { ...withUpstreamHttpVersion(input, init, provider), timeout: 0,
+        ...(options.onPhysicalDispatch ? { [PHYSICAL_DISPATCH]: () => {
+          if (sharedReceipt) sharedReceipt();
+          else if (!notified) { options.onPhysicalDispatch!(); notified = true; }
+        } } : {}),
+      };
       return options.dispatchOverride
         ? options.dispatchOverride(input, dispatchInit, dispatch)
         : dispatch(input, dispatchInit);
@@ -332,8 +347,16 @@ export function providerFetch(
       // used, protocol pin included: a WS turn that falls back is serving the
       // request over HTTP, and dropping the provider's `upstreamHttpVersion`
       // there would silently negotiate a transport the operator ruled out.
-      return codexWsUpstreamFetch(input, init, httpFetch, runtime, options.onCodexWsQuota, options.beforeDispatch, options.nativeControl,
-        async () => { (await waitForPacing(init.signal ?? undefined))?.release(); });
+      let notified = false;
+      const notifyOnce = (): void => {
+        if (notified) return;
+        notified = true;
+        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;
+      return codexWsUpstreamFetch(input, init, fallback, runtime, options.onCodexWsQuota, options.beforeDispatch, options.nativeControl,
+        async () => { (await waitForPacing(init.signal ?? undefined))?.release(); }, notifyOnce);
     }
     return httpFetch(input, init);
   };

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

@@ -24,13 +24,16 @@ import { teeWithBoundedInspection } from "../inspection-tee";
 import {
   codexForwardTerminalOutcomeRecorder,
   usesCodexForwardPoolAuth,
+  liveMainQuotaDispatch,
   codexQuotaOutcomeMeta,
   codexDenialOutcomeMeta,
   isFixedCodexAccount,
   shouldDeferCodexResetDerivedCooldown,
 } from "./core-codex-account";
+import { isMainQuotaDispatchLive, isMainQuotaDispatchWsClaimed } from "../../codex/main-account-cache";
+import { MAIN_CODEX_ACCOUNT_ID } from "../../codex/account-id";
 import type { ResponsesTerminalStatus } from "../../bridge";
-import { isCodexWsQuotaObservedResponse, isCodexWsUpstreamResponse } from "./ws-upstream";
+import { isCodexWsQuotaObservedResponse, isCodexWsUpstreamResponse, isCodexWsPreludeProjection } from "./ws-upstream";
 import { recordSubagentQuotaFailureForThreadSpawn } from "../../codex/subagent-model-fallback";
 import { recordCodexUpstreamOutcome } from "../../codex/routing";
 import { codexProbeLeaseId, codexProbeQuotaScope, codexTransientProbeGrant, releaseCodexAuthContextProbeLease } from "../../codex/auth-context";
@@ -139,6 +142,7 @@ import {
   httpStatusFromTerminalError,
   inspectResponseLogJson,
   inspectResponseLogSsePayloadParsed,
+  noteUpstreamRequestId,
 } from "../request-log";
 import { restoreRoutedCustomCallsInJson } from "../../responses/custom-tool-compat";
 import { restoreRoutedToolSearchCallsInJson } from "../../responses/tool-search-compat";
@@ -406,6 +410,9 @@ export async function deliverPassthroughResponse(
     | "localUpstream"
   >,
 ): Promise<Response> {
+  const { route } = requestState;
+  // The proof must belong to the response whose headers are published.
+  const arrivalMainDispatch = liveMainQuotaDispatch(admissionState.authCtx, route.provider);
   const { logCtx, config, options, req } = requestContext;
   const {
     codexSafetyBufferingOptions,
@@ -429,7 +436,7 @@ export async function deliverPassthroughResponse(
     normalizeFunctionCompletionJson,
   } = nativeExchange;
   const { commitReasoningReplayServingRoute, recordTerminalOutcomes } = responseEffects;
-  const { parsed, route, subagentQuotaFailureModel, clientRequestedStream, translatorBudget, inboundWire } = requestState;
+  const { parsed, subagentQuotaFailureModel, clientRequestedStream, translatorBudget, inboundWire } = requestState;
   const enforceDeclaredToolNames = inboundWire !== "chat" && inboundWire !== "anthropic";
   const { openAiSidecar } = sidecarState;
   const { requestBindings } = transportState;
@@ -452,6 +459,7 @@ export async function deliverPassthroughResponse(
   }
 
     const headers = sanitizePassthroughHeaders(upstreamResponse.headers, codexSafetyBufferingOptions);
+    if (!upstreamResponse.ok) noteUpstreamRequestId(logCtx, headers);
     const resolvedModel = headers.get("openai-model")?.trim();
     if (resolvedModel) {
       logCtx.servedModel = resolvedModel;
@@ -535,6 +543,20 @@ export async function deliverPassthroughResponse(
           ...(admissionState.authCtx.kind === "pool" ? { credentialGeneration: admissionState.authCtx.generation } : {}),
         });
       }
+    } else {
+      // The WS observer is the only plain-main publisher for a WebSocket exchange;
+      // a prelude projection carries the prelude snapshot, not fresh evidence.
+      // The dispatch claim is authoritative because downstream wrappers can replace the Response.
+      if (arrivalMainDispatch && !isMainQuotaDispatchWsClaimed(arrivalMainDispatch)
+        && !(isCodexWsUpstreamResponse(upstreamResponse) || isCodexWsPreludeProjection(upstreamResponse))) {
+        const { applyAccountQuotaFromUpstreamHeaders } = await import("../../codex/auth-api");
+        // Import yields; same-account token replacement leaves the identity writer live.
+        // Re-check the credential fence with no await before publication.
+        if (isMainQuotaDispatchLive(arrivalMainDispatch)) {
+          applyAccountQuotaFromUpstreamHeaders(MAIN_CODEX_ACCOUNT_ID, upstreamResponse.headers,
+            arrivalMainDispatch.configGeneration, arrivalMainDispatch.writer, { modelId: route.modelId });
+        }
+      }
     }
 
     // Non-2xx passthrough failures must never reach Codex as an empty body —

package/src/server/responses/passthrough-dispatch.ts

@@ -12,6 +12,7 @@ import type { ResponsesTransport } from "./request-transport";
 import type { ResponsesEffects } from "./response-effects";
 import type { ResponsesSendBudget } from "./request-send-budget";
 import { transientSendCapFor } from "./request-send-budget";
+import { renewMainQuotaDispatchForAttempt } from "../../codex/main-account-cache";
 import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers";
 import { isLocalUpstream } from "../../lib/local-upstream";
 import { codexSafetyBufferingFilterOptions, terminalStatusFromParsed } from "../relay";
@@ -225,6 +226,10 @@ export async function preparePassthroughExchange(
     | "pendingHopPermit"
     | "workflowRootId"
     | "sendsUsed"
+    | "targetSendsUsed"
+    | "initialSendAllowance"
+    | "noteInitialDispatch"
+    | "adapterSendBudget"
   >,
 ) {
   const { config, logCtx, options, req } = requestContext;
@@ -753,7 +758,7 @@ export async function preparePassthroughExchange(
     const transientSendPolicy = () => transientRetryPolicyFor(route.provider);
     const transientSendAttempts = (): number => transientSendCapFor(
       transientSendPolicy()?.attempts,
-      sendBudgetState.sendsUsed,
+      sendBudgetState.targetSendsUsed,
     );
     const configuredTransientSendBudgetExhausted = (): boolean =>
       transientSendPolicy() !== null && transientSendAttempts() === 0;
@@ -798,6 +803,9 @@ export async function preparePassthroughExchange(
     const sendAmbiguousReplacement = (
       signal: AbortSignal = upstream.signal,
     ): Promise<Response> => {
+      if (admissionState.authCtx.kind === "main" && admissionState.authCtx.mainQuotaDispatch) {
+        admissionState.authCtx.mainQuotaDispatch = renewMainQuotaDispatchForAttempt(admissionState.authCtx.mainQuotaDispatch);
+      }
       const report = transientSendReporter();
       let started = false;
       const run = () => fetchWithHeaderTimeout(
@@ -968,6 +976,11 @@ export async function preparePassthroughExchange(
     };
     const initialBodyRefusal = refuseOversizedOutboundBody(request);
     if (initialBodyRefusal) return initialBodyRefusal;
+    // A combo-owned first send is settled by the physical-dispatch receipt unless spend
+    // enforcement is on, where the shared reporter already owns the permit lifecycle.
+    // Stable per request: the Combo booking (`reserveDispatch`) already started and froze the spend
+    // policy, so `spendEnforced` cannot change before dispatch even though no reporter starts it here.
+    const receiptMode = !sendBudgetState.adapterSendBudget?.spendEnforced && Boolean(options.comboInitialSend);
     try {
       // Transient-5xx pre-stream retry (devlog/_plan/260716_claudecode_hardening/010):
       // the ChatGPT backend emits transient 502/520s that an immediate retry absorbs.
@@ -994,6 +1007,7 @@ export async function preparePassthroughExchange(
               dispatchOverride: oauthDispatch(request),
               providerName: route.providerName,
               modelId: route.modelId,
+              onPhysicalDispatch: receiptMode ? sendBudgetState.noteInitialDispatch : undefined,
               onCodexWsQuota: codexWsQuotaObserver(admissionState.authCtx, route.provider, route.modelId),
               beforeDispatch: isCanonicalOpenAiForwardProvider(route.provider)
                 ? createCodexAuthDispatchGuard(admissionState.authCtx, options.codexAuthPolicy ?? config, route.modelId, options.admission, options.visionDescribeTerminal === true) : undefined,
@@ -1004,7 +1018,10 @@ export async function preparePassthroughExchange(
             .then(adoptObservedResponse);
         },
         { abortSignal: upstream.signal, label: safeHostLabel(request.url),
-          attempts: remainingTransientSendBudget(transientSendAttempts()), onSendsConsumed: transientSendReporter(),
+          attempts: sendBudgetState.initialSendAllowance(transientSendAttempts()),
+          // Reporter path: direct requests and enforced spend. Receipt-mode sends are settled
+          // by `onPhysicalDispatch`; a reporter as well would count them twice.
+          ...(receiptMode ? {} : { onSendsConsumed: transientSendReporter() }),
           claimAmbiguousResend: claimPreHeaderResend,
         },
       );

package/src/server/responses/request-prepare.ts

@@ -381,6 +381,10 @@ export async function prepareResponsesRequest(
   let toolBridgeMaps: ReturnType<typeof buildToolBridgeMaps>;
   try {
     parsed = parseRequest(body);
+    if (options.inboundWire === "anthropic") {
+      parsed._nativeReasoningReplay = options.nativeReasoningReplay;
+      parsed._nativeReasoningMint = options.nativeReasoningMint;
+    }
     parsed._promptCacheKeyIsSharedCohort = options.promptCacheKeyIsSharedCohort;
     // The body may have been rebuilt since the inbound observation (previous-response
     // expansion); alias the parsed raw body to the same draft so the outbound

package/src/server/responses/request-send-budget.ts

@@ -9,7 +9,7 @@ import {
 import { poolContinuityRefusalReason, workflowRefusalResponse } from "../workflow-refusal";
 import type { AttemptRecoveryKind, AttemptRecoveryWithheld } from "../../usage/log";
 import { noteAttemptRecoveryWithheld, noteAttemptSend } from "../request-log";
-import { TRANSIENT_RETRY_MAX_ATTEMPTS } from "../../lib/upstream-retry";
+import { TRANSIENT_RETRY_MAX_ATTEMPTS, SendBudgetExhaustedError } from "../../lib/upstream-retry";
 import type {
   DispatchDecision,
   DispatchIntent,
@@ -58,10 +58,24 @@ export function createResponsesSendBudget(
   // sends once per child seven hundred times, so every send charged to the request is charged
   // to the root as well (#4546).
   const workflowRootId = req.headers.get("x-codex-parent-thread-id")?.trim() || undefined;
-  const inheritedPermit = options.compactionRecoveryPermit ?? options.comboDispatchPermit;
+  // A child that owns its Combo booking settles that exact permit through the reporter, even
+  // when its caller handed ownership over only as `comboInitialSend`.
+  const inheritedPermit = options.compactionRecoveryPermit ?? options.comboDispatchPermit
+    ?? options.comboInitialSend?.permit;
   let pendingHopPermit: SingleUseDispatchPermit | undefined = options.compactionRecoveryPermit;
+  let initialPermit = options.comboInitialSend?.permit;
+  // Count this owner's physical sends, not later bookings made by other shared-ledger owners.
+  // Direct callers retain sends reported before this owner was constructed.
+  let targetSendsUsed = initialPermit ? 0 : Math.max(0,
+    sendBudget.used - (options.compactionRecoveryPermit ? 1 : 0));
+  /** Attribute reported physical sends to this owner; the prepaid booking is spent once reported. */
+  const noteTargetSends = (charged: number): void => {
+    targetSendsUsed += charged;
+    if (charged > 0) initialPermit = undefined;
+  };
   const recordTransientSends = (used: number, permit?: SingleUseDispatchPermit): void => {
     const charged = Math.max(0, used);
+    noteTargetSends(charged);
     reportDispatchSends(sendBudget, charged, permit);
     options.onCompactionRecoverySendsReported?.(charged);
     chargeWorkflowSends(workflowRootId, charged);
@@ -71,6 +85,7 @@ export function createResponsesSendBudget(
   const transientSendReporter = (permit = pendingHopPermit ?? inheritedPermit) =>
     createPhysicalSendReporter(sendBudget, () => ({ poolId: logCtx.spendPoolId ?? logCtx.provider,
       identityId: logCtx.accountLogLabel }), permit, charged => {
+      noteTargetSends(Math.max(0, charged));
       options.onCompactionRecoverySendsReported?.(charged);
       chargeWorkflowSends(workflowRootId, charged);
     });
@@ -136,6 +151,7 @@ export function createResponsesSendBudget(
     // Ordinal 1 is skipped because the caller normally records it before dispatch. An adapter
     // that reports every send asks for it to be counted here instead, so that the first send is
     // logged where it actually happens rather than before admission could still refuse it.
+    targetSendsUsed += 1;
     if (send.ordinal <= 1 && options.includeFirst !== true) return;
     noteAttemptSend(logCtx.activeAttempt, inputTokens, send.recovery);
   };
@@ -191,21 +207,29 @@ export function createResponsesSendBudget(
    * The hop hands its reservation down through `pendingHopPermit`, the same seam the
    * passthrough ladder already uses, and this view spends it on the adapter's FIRST
    * reservation. Every later send in that ladder is a new physical send and is charged
-   * normally. The refundable view below keeps an unused hop open until executor invocation;
-   * its adapter release hands back an abandoned replay. The ordinary view retains early
-   * settlement for existing callers.
+   * normally. Claiming preserves the refundable single-use booking until physical dispatch;
+   * an abandoned replay releases only that exact booking.
    */
-  const claimHopPermit = (): SingleUseDispatchPermit | undefined => {
-    const permit = pendingHopPermit;
-    pendingHopPermit = undefined;
-    return permit;
+  const permits = {
+    /** Transfer the initial booking once to the adapter dispatch owner. */
+    claimInitialPermit: () => {
+      const permit = initialPermit;
+      initialPermit = undefined;
+      return permit;
+    },
+    /** Transfer a pending recovery booking once, without creating a new allowance. */
+    claimHopPermit: () => {
+      const permit = pendingHopPermit;
+      pendingHopPermit = undefined;
+      return permit;
+    },
   };
-  const adapterDispatchBudget: RequestExecutionBudget | undefined = adapterSendBudget === undefined
-    ? undefined : adapterDispatchBudgetView(adapterSendBudget, { claimHopPermit });
-  // Opt in only where the adapter's executor is the confirmation boundary. Ordinary callers
-  // keep the existing early settlement contract, including already-settled permit fallback.
-  const refundableAdapterDispatchBudget: RequestExecutionBudget | undefined = adapterSendBudget === undefined
-    ? undefined : adapterDispatchBudgetView(adapterSendBudget, { claimHopPermit }, true);
+  const adapterDispatchBudget = adapterSendBudget === undefined
+    ? undefined : adapterDispatchBudgetView(adapterSendBudget, permits);
+  // Preserve the existing opted-in view for direct callers, including its admitted replacement
+  // of an already-settled hop. Exact-owned Combo and sidecar handoffs use the ordinary view.
+  const refundableAdapterDispatchBudget = adapterSendBudget === undefined
+    ? undefined : adapterDispatchBudgetView(adapterSendBudget, permits, true);
   /**
    * How many sends a recovery leg may make, and the permit that authorises the last one.
    *
@@ -292,12 +316,34 @@ export function createResponsesSendBudget(
     noteTransientSends,
     transientSendReporter,
     remainingTransientSendBudget,
+    /** Only this child's prepaid send, not every pending external booking, is spendable here. */
+    initialSendAllowance: (cap: number): number => Math.min(cap,
+      remainingTransientSendBudget(cap) + (initialPermit ? 1 : 0)),
+    /** At final executor admission, settle only the owning booking or reserve this send. */
+    noteInitialDispatch: (prepaid = initialPermit): void => {
+      if (prepaid) {
+        if (!prepaid.assumeCharge()) throw new SendBudgetExhaustedError();
+        if (prepaid === initialPermit) initialPermit = undefined;
+      } else if (adapterSendBudget && (options.comboInitialSend || options.compactionRecoveryPermit)) {
+        const decision = adapterSendBudget.reserveDispatch({ sendClass: "transient",
+          targetKey: adapterSendBudget.lastTargetKey ?? `${logCtx.provider}/${logCtx.model}` });
+        if (!decision.allowed || !decision.permit.use()) throw new SendBudgetExhaustedError();
+      } else {
+        // Legacy direct callers can prebook without handing over a permit; keep their reporter.
+        noteTransientSends(1);
+        return;
+      }
+      targetSendsUsed += 1;
+      options.onCompactionRecoverySendsReported?.(1);
+      chargeWorkflowSends(workflowRootId, 1);
+    },
+    /** Physical sends reported by this owner; unrelated shared reservations cannot consume it. */
+    get targetSendsUsed(): number { return targetSendsUsed; },
     /**
-     * Physical sends this logical request has already made.
+     * Charged sends, including open prepaid reservations, across this logical request.
      *
-     * A live getter, not a snapshot: it is read once per dispatch leg to resolve a configured
-     * ladder, and a value frozen at construction would answer for a request that had sent
-     * nothing.
+     * A live getter, not a completed-send snapshot. Initial ladders use the child's own
+     * prepaid allowance and target-local count; shared admission keeps every booking spent.
      */
     get sendsUsed(): number { return sendBudget.used; },
     adapterSendBudget,
@@ -335,8 +381,11 @@ export type ResponsesSendBudget = Exclude<ReturnType<typeof createResponsesSendB
  */
 function adapterDispatchBudgetView(
   budget: RequestExecutionBudget,
-  hop: { claimHopPermit: () => SingleUseDispatchPermit | undefined },
-  refundableHop = false,
+  hop: {
+    claimInitialPermit: () => SingleUseDispatchPermit | undefined;
+    claimHopPermit: () => SingleUseDispatchPermit | undefined;
+  },
+  legacyHopReplacement = false,
 ): RequestExecutionBudget {
   return {
     get physicalStarted() { return budget.physicalStarted; },
@@ -360,10 +409,22 @@ function adapterDispatchBudgetView(
     claimAmbiguousResend: (limit: number): boolean => budget.claimAmbiguousResend?.(limit) === true,
     get ambiguousResendSpent(): boolean { return budget.ambiguousResendSpent === true; },
     reserveDispatch(intent: DispatchIntent): DispatchDecision {
-      const refundable = refundableHop || budget.spendEnforced === true;
       // A dispatch whose upstream state is unknown is refused on its own merits. A hop that
       // already paid does not make an unsafe replay safe, so that check stays with the budget.
       if (intent.replaySafe !== false) {
+        // The Combo reserves a logical provider/model identity. The child's first actual
+        // endpoint is not a recovery transition; retain the original refundable permit.
+        const initialPermit = hop.claimInitialPermit();
+        if (initialPermit) {
+          budget.bindPrepaidTarget?.(intent.targetKey);
+          return { allowed: true, permit: {
+            sendClass: initialPermit.sendClass,
+            execute: run => initialPermit.execute ? initialPermit.execute(run) : run(),
+            use: () => initialPermit.assumeCharge(),
+            assumeCharge: () => initialPermit.assumeCharge(),
+            release: () => initialPermit.release(),
+          } };
+        }
         const hopPermit = hop.claimHopPermit();
         if (hopPermit && intent.targetKey !== budget.lastTargetKey) {
           // The rotated credential can select a different regional endpoint. Replace the
@@ -372,35 +433,37 @@ function adapterDispatchBudgetView(
           hopPermit.release();
           return budget.reserveDispatch({ ...intent, sendClass: hopPermit.sendClass });
         }
-        if (hopPermit !== undefined && (refundable || hopPermit.assumeCharge())) {
-          let settled = false;
-          let executionPermit = hopPermit;
-          const confirm = (): boolean => {
-            if (settled) return false;
-            settled = true;
-            // Admission can still reject this replay. Close its external booking only when
-            // the adapter invokes its executor, leaving release() able to refund it until then.
-            if (!refundable || hopPermit.assumeCharge()) return true;
-            // Preserve the old fallback for a permit another leg already settled.
-            const fresh = budget.reserveDispatch(intent);
-            if (!fresh.allowed) return false;
-            executionPermit = fresh.permit;
-            return fresh.permit.assumeCharge();
-          };
-          return {
-            allowed: true,
-            permit: {
+        // Reservation precedes pacing and beforeDispatch. Transfer the exact open booking;
+        // only physical consumption closes external reporting and makes it non-refundable.
+        // The underlying permit enforces single use, including settlement by another owner.
+        if (hopPermit !== undefined) {
+          if (legacyHopReplacement) {
+            let settled = false;
+            let executionPermit = hopPermit;
+            const confirm = (): boolean => {
+              if (settled) return false;
+              settled = true;
+              if (hopPermit.assumeCharge()) return true;
+              // Preserve the old fallback for a permit another leg already settled.
+              const fresh = budget.reserveDispatch(intent);
+              if (!fresh.allowed) return false;
+              executionPermit = fresh.permit;
+              return fresh.permit.assumeCharge();
+            };
+            return { allowed: true, permit: {
               sendClass: hopPermit.sendClass,
               execute: run => executionPermit.execute ? executionPermit.execute(run) : run(),
-              use: confirm,
-              assumeCharge: confirm,
-              release: (): void => {
-                if (!refundable || settled) return;
-                settled = true;
-                hopPermit.release();
-              },
-            },
-          };
+              use: confirm, assumeCharge: confirm,
+              release: () => { if (!settled) { settled = true; hopPermit.release(); } },
+            } };
+          }
+          return { allowed: true, permit: {
+            sendClass: hopPermit.sendClass,
+            execute: run => hopPermit.execute ? hopPermit.execute(run) : run(),
+            use: () => hopPermit.assumeCharge(),
+            assumeCharge: () => hopPermit.assumeCharge(),
+            release: () => hopPermit.release(),
+          } };
         }
       }
       return budget.reserveDispatch(intent);

package/src/server/responses/response-effects.ts

@@ -75,6 +75,7 @@ export function createResponsesEffects(
   // message, and leave Codex fataling on a missing compaction item (#422).
   const commitReasoningReplayServingRoute = (outboundHeaders?: HeadersInit): void => {
     commitReasoningReplayServingIdentity(parsed._reasoningReplayScope);
+    if (parsed._nativeReasoningMint) parsed._nativeReasoningMint.owner = parsed._nativeReasoningBoundOwner;
     rememberServingConversationStateIssuer(admissionState.authCtx, poolAffinityKey);
     // History has no model namespace. Record the account that actually accepted this
     // final attempt, after refresh/failover, rather than guessing from mutable affinity.

package/src/server/responses/run-turn-execution.ts

@@ -235,6 +235,7 @@ export async function executeResponsesRunTurn(
       preacquiredSlot?: ProviderRequestSlot,
     ): Promise<void> => {
       const attemptSeq = ++runTurnAttemptSeq;
+      if (attemptSeq === 1 && options.comboInitialSend) options.comboInitialSend.producerOwned = true;
       let pacingSlot = preacquiredSlot;
       const emit = (event: AdapterEvent) => {
         options.onCompactionRecoveryAdapterEvent?.(event);
@@ -339,6 +340,7 @@ export async function executeResponsesRunTurn(
                 message: err instanceof Error ? err.message : String(err),
               });
       } finally {
+        if (attemptSeq === 1) options.comboInitialSend?.permit.release();
         devinProducers.delete(producerAbort);
         cleanupProducerAbort?.();
         releaseProviderRequestSlot(pacingSlot);

package/src/server/responses/sidecar-execution.ts

@@ -48,6 +48,7 @@ import { normalizeLogConversationId } from "../request-log-conversation";
 import { rememberResponseState } from "../../responses/state";
 import { trackStreamLifetime } from "../lifecycle";
 import { isAntigravityRawValidationRefusal } from "./antigravity-validation-refusal";
+import { createSidecarSendBudget } from "./sidecar-send-budget";
 
 /** One responsibility of the Responses request pipeline; state owners are explicit. */
 export async function executeResponsesSidecars(
@@ -90,7 +91,7 @@ export async function executeResponsesSidecars(
     | "notifyResponseComplete"
     | "cancelResponseCompletion"
   >,
-  sendBudgetState: Pick<ResponsesSendBudget, "reserveCredentialHop" | "refundableAdapterDispatchBudget" | "pendingHopPermit" | "noteAdapterPhysicalSend">,
+  sendBudgetState: Pick<ResponsesSendBudget, "reserveCredentialHop" | "refundableAdapterDispatchBudget" | "adapterDispatchBudget" | "noteInitialDispatch" | "noteAdapterPhysicalSend" | "noteAdapterRecoveryWithheld" | "pendingHopPermit">,
 ) {
   const { config, options, logCtx } = requestContext;
   const antigravityPoolActivated = requestState.route.providerName === "google-antigravity"
@@ -114,6 +115,7 @@ export async function executeResponsesSidecars(
   } = requestState;
   const { routedCompaction, openAiSidecar } = sidecarState;
   const { reserveCredentialHop } = sendBudgetState;
+  const sidecarBudget = createSidecarSendBudget(options, sendBudgetState, () => logCtx.usageLogInputTokens);
   const {
     commitReasoningReplayServingRoute,
     continuationStateForResponse,
@@ -202,7 +204,7 @@ export async function executeResponsesSidecars(
   ): Promise<{ adapter: ProviderAdapter; recoveryKind: AttemptRecoveryKind } | null> => {
     const antigravityValidationResponse = canRunWebSearch && route.providerName === "google-antigravity"
       && route.provider.authMode === "oauth" && originalResponse?.status === 403;
-    if (route.providerName !== "kiro" && !(anthropicInstance && originalResponse?.status === 403)
+    if (route.providerName !== "kiro" && !(anthropicInstance && (originalResponse?.status === 403 || originalResponse?.status === 401))
       && !antigravityValidationResponse && originalResponse && originalResponse.status !== 429) return null;
     let antigravityVerification = false;
     if (antigravityValidationResponse) {
@@ -264,7 +266,8 @@ export async function executeResponsesSidecars(
         return null;
       }
       recoveryKind = "oauth-account-403";
-      sendBudgetState.pendingHopPermit = hop.permit;
+      if (!options.comboInitialSend) sendBudgetState.pendingHopPermit = hop.permit;
+      else sidecarBudget.ownCredentialHop(hop.permit);
     }
     const rotated = !originalResponse || originalResponse.status === 429
       ? rotateProviderTransportOn429(config, route.providerName, route.provider, {
@@ -323,8 +326,9 @@ export async function executeResponsesSidecars(
         return null;
       }
       recoveryKind = "oauth-account-429";
-      if (canRunWebSearch && route.providerName === "google-antigravity") sendBudgetState.pendingHopPermit = hop.permit;
-      else hop.permit?.use();
+      if (!options.comboInitialSend && canRunWebSearch && route.providerName === "google-antigravity")
+        sendBudgetState.pendingHopPermit = hop.permit;
+      else sidecarBudget.ownCredentialHop(hop.permit);
     } else if (
       // Anthropic's pool is excluded from generic failover, so without this arm a 429 inside a
       // web-search or image-bridge turn was terminal even with the pool fully enabled -- while
@@ -364,8 +368,8 @@ export async function executeResponsesSidecars(
         hop.permit?.release();
         return null;
       }
-      recoveryKind = "anthropic-oauth-429";
-      hop.permit?.use();
+      recoveryKind = originalResponse?.status === 401 ? "oauth-401" : "anthropic-oauth-429";
+      sidecarBudget.ownCredentialHop(hop.permit);
     } else {
       // No key pool, no generic OAuth roster, no Anthropic pool could produce a replacement
       // credential. The 429 is terminal for this sidecar turn.
@@ -451,11 +455,14 @@ export async function executeResponsesSidecars(
     const imageProviderFetch = providerFetch(
       route.provider,
       options.codexWsRuntimeIdentity,
-      { providerName: route.providerName, modelId: route.modelId },
+      { providerName: route.providerName, modelId: route.modelId, ...sidecarBudget.fetchOptions(transportState.adapter) },
     );
     const imgResponse = await runWithImageBridge({
       parsed, adapter: transportState.adapter,
-      incomingMeta: { headers: requestState.selectedForwardHeaders, providerName: route.providerName, abortSignal: options.abortSignal, translatorBudget },
+      incomingMeta: { headers: requestState.selectedForwardHeaders, providerName: route.providerName, abortSignal: options.abortSignal, translatorBudget, ...(options.comboInitialSend ? { providerFetch: imageProviderFetch } : {}), ...sidecarBudget.incomingMeta },
+      onProducerStart: sidecarBudget.takeProducerOwnership,
+      onProducerEnd: sidecarBudget.release,
+      onIterationEnd: sidecarBudget.releaseUnsentHop,
       ...(imgPlan ? { plan: imgPlan } : {}),
       ...(vidPlan ? { videoPlan: vidPlan } : {}),
       forwardHeaders: requestState.selectedForwardHeaders,
@@ -471,10 +478,10 @@ export async function executeResponsesSidecars(
       stallTimeoutSec: config.stallTimeoutSec,
       waitForRequestSlot: imageProviderFetch.waitForPacing,
       fetchImpl: imageProviderFetch.unpacedFetch ?? imageProviderFetch,
-      fetchForRequest: (request, iterParsed) => {
+      fetchForRequest: (request, iterParsed, adapter) => {
         const fetch = providerFetch(route.provider, options.codexWsRuntimeIdentity, {
           dispatchOverride: oauthDispatch(request, iterParsed),
-          providerName: route.providerName, modelId: route.modelId,
+          providerName: route.providerName, modelId: route.modelId, ...sidecarBudget.fetchOptions(adapter),
         });
         return fetch.unpacedFetch ?? fetch;
       },
@@ -541,12 +548,14 @@ export async function executeResponsesSidecars(
       providerFetch(route.provider, options.codexWsRuntimeIdentity, {
         providerName: route.providerName,
         modelId: route.modelId,
+        ...sidecarBudget.fetchOptions(transportState.adapter),
       })(input, init)) as typeof globalThis.fetch;
     const wsResponse = await runWithWebSearch({
       parsed, adapter: transportState.adapter,
-      fetchForRequest: (request, iterParsed) => providerFetch(route.provider, options.codexWsRuntimeIdentity, {
+      onIterationEnd: sidecarBudget.releaseUnsentHop,
+      fetchForRequest: (request, iterParsed, adapter) => providerFetch(route.provider, options.codexWsRuntimeIdentity, {
         dispatchOverride: oauthDispatch(request, iterParsed),
-        providerName: route.providerName, modelId: route.modelId,
+        providerName: route.providerName, modelId: route.modelId, ...sidecarBudget.fetchOptions(adapter),
       }),
       incomingMeta: {
         headers: requestState.selectedForwardHeaders,
@@ -554,11 +563,11 @@ export async function executeResponsesSidecars(
         abortSignal: options.abortSignal,
         translatorBudget,
         providerFetch: routedProviderFetch,
-        ...(route.providerName === "google-antigravity" ? {
+        ...(!options.comboInitialSend && route.providerName === "google-antigravity" ? {
           sendBudget: sendBudgetState.refundableAdapterDispatchBudget,
           onPhysicalSend: (send: { ordinal: number; recovery?: AttemptRecoveryKind }) =>
             sendBudgetState.noteAdapterPhysicalSend(logCtx.usageLogInputTokens, send),
-        } : {}),
+        } : sidecarBudget.incomingMeta),
       },
       backend: wsPlan.backend,
       forwardProvider: wsPlan.forwardSidecar?.provider,
@@ -591,7 +600,7 @@ export async function executeResponsesSidecars(
       stallTimeoutSec: wsPlan.stallTimeoutSec,
       streamRoutedModelOutput: wsPlan.streamRoutedModelOutput,
       on429: rotateSidecarProviderOn429,
-      ...(route.providerName === "google-antigravity" ? { onIterationEnd: () => {
+      ...(!options.comboInitialSend && route.providerName === "google-antigravity" ? { onIterationEnd: () => {
         // The next Antigravity adapter dispatch claims this permit. If request construction,
         // admission or cancellation stopped it first, return the unused send allowance.
         const permit = sendBudgetState.pendingHopPermit;