@bitkyc08/opencodex 2.88.0 → 2.90.0

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

@@ -0,0 +1,38 @@
+import { readCodexWsStage } from "./codex-ws-wire";
+import type { RequestLogContext } from "../request-log";
+
+/**
+ * #4191: a Codex WS exchange pins its content-free stage record on the
+ * Response it resolves (markCodexWsStage). Adopting the record here, at
+ * the single funnel every physical upstream response passes through,
+ * binds it to the attempt that actually served it — including the 502/504
+ * pre-response JSON settles that never reach the SSE relay.
+ */
+export function adoptCodexWsStage(response: Response, logCtx: RequestLogContext): void {
+  const stage = readCodexWsStage(response);
+  if (stage && logCtx.activeAttempt) logCtx.activeAttempt.codexWsStage = stage;
+}
+
+import type { CodexAuthContext } from "../../codex/auth-context";
+import type { RouteResult } from "../../router";
+import { captureCodexAffinityDiagnostic } from "../../codex/affinity-debug";
+import { ACCOUNT_GATED_NATIVE_OPENAI_MODELS } from "../../codex/catalog/native-models";
+import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers";
+import { isFixedCodexAccount } from "./core-codex-account";
+
+export function capturePassthroughAffinity(response: Response, inboundHeaders: Headers, outboundHeaders: Record<string, string>,
+  captureAuthCtx: CodexAuthContext, route: Pick<RouteResult, "provider" | "modelId" | "codexAccountMode">,
+  parsedModelId: string, credentialSubstituted: boolean): void {
+  if (!isCanonicalOpenAiForwardProvider(route.provider)) return;
+  captureCodexAffinityDiagnostic({
+    inboundHeaders: inboundHeaders,
+    outboundHeaders: outboundHeaders,
+    authKind: captureAuthCtx.kind,
+    accountMode: route.codexAccountMode,
+    fixedAccount: isFixedCodexAccount(captureAuthCtx),
+    credentialSubstituted,
+    accountGatedModel: ACCOUNT_GATED_NATIVE_OPENAI_MODELS.has(route.modelId),
+    wireModelNormalized: parsedModelId !== route.modelId,
+    status: response.status,
+  });
+}

package/src/server/responses/reasoning-archive-error.ts

@@ -0,0 +1,21 @@
+import { formatErrorResponse } from "../../bridge";
+import { ReasoningArchiveBusyError, ReasoningArchiveError,
+  ReasoningArchiveQuotaError } from "../../responses/reasoning-retention";
+
+/** Local storage refusal before any send. Never expose filesystem messages or causes. */
+export function reasoningArchiveErrorResponse(error: unknown): Response | undefined {
+  let code: string;
+  let message: string;
+  if (error instanceof ReasoningArchiveQuotaError) {
+    code = "reasoning_archive_quota_exceeded";
+    message = "Local reasoning archive is full. Review and manually remove older reasoning archives, then retry the unchanged request.";
+  } else if (error instanceof ReasoningArchiveBusyError) {
+    code = "reasoning_archive_busy";
+    message = "Another local reasoning archive writer is active. Wait for it to finish, then retry the unchanged request.";
+  } else if (error instanceof ReasoningArchiveError) {
+    code = "reasoning_archive_unavailable";
+    message = "Local reasoning archive is unavailable. Check archive directory permissions and local storage health before retrying the unchanged request.";
+  } else return undefined;
+  // Match the local spend-ledger storage refusal's 503 convention without guessing a delay.
+  return formatErrorResponse(503, "server_error", message, { code, classified: true });
+}

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

@@ -0,0 +1,98 @@
+import { Buffer } from "node:buffer";
+import { constants, gzipSync, zstdCompressSync } from "node:zlib";
+import type { OcxConfig } from "../../types";
+
+/**
+ * Opt-in compression of outbound native ChatGPT Responses HTTP request bodies (#7247).
+ *
+ * Codex re-sends the whole conversation on every turn. When that turn travels over HTTP the body
+ * reaches `chatgpt.com` identity-encoded, which on a metered egress is the dominant cost of
+ * running Codex through the proxy. The backend already accepts coded request bodies: Codex CLI
+ * itself sends `content-encoding: zstd` there (see `src/server/request-decompress.ts`).
+ *
+ * Applied only at the final HTTP send (`sendWithConnectionPolicy`), after the WebSocket decision
+ * and plugin rewrites, so WebSocket frames and every other destination are untouched.
+ *
+ * Compression is synchronous on purpose. An await at the physical-send boundary would open a gap
+ * between dispatch admission (credential selection, attempt receipts, live reserve policy) and the
+ * send itself. The cost is bounded instead: bodies above {@link MAX_COMPRESSIBLE_BODY_BYTES} are sent
+ * as they are, which keeps the event-loop block to tens of milliseconds on ordinary hardware.
+ */
+export type UpstreamRequestCompression = "off" | "gzip" | "zstd";
+
+/** Below this the header overhead outweighs any saving. */
+export const MIN_COMPRESSIBLE_BODY_BYTES = 1024;
+/** Above this the synchronous compression block is no longer negligible; send identity. */
+export const MAX_COMPRESSIBLE_BODY_BYTES = 16 * 1024 * 1024;
+
+const CANONICAL_CODEX_RESPONSES = /^https:\/\/chatgpt\.com\/backend-api\/codex\/responses(?:\/compact)?$/;
+
+/** True for the native ChatGPT Responses and compact endpoints, the only compressed destinations. */
+export function isCanonicalCodexResponsesUrl(url: string): boolean {
+  return CANONICAL_CODEX_RESPONSES.test(url);
+}
+
+/** Anything other than an explicit codec, including a malformed hand edit, means off. */
+export function resolveUpstreamRequestCompression(value: unknown): UpstreamRequestCompression {
+  return value === "gzip" || value === "zstd" ? value : "off";
+}
+
+// The live server config object, installed once at startup by `setLiveStateStoreConfig`. Live
+// reconciliation mutates that object in place, so the field is read per send rather than copied.
+let boundConfig: Pick<OcxConfig, "upstreamRequestCompression"> | null = null;
+
+export function bindUpstreamRequestCompressionConfig(config: Pick<OcxConfig, "upstreamRequestCompression"> | null): void {
+  boundConfig = config;
+}
+
+export function currentUpstreamRequestCompression(): UpstreamRequestCompression {
+  return resolveUpstreamRequestCompression(boundConfig?.upstreamRequestCompression);
+}
+
+// ArrayBuffer-backed, which is what node:zlib returns and what a fetch BodyInit accepts.
+type CodedBytes = Buffer<ArrayBuffer>;
+type Compressor = (mode: Exclude<UpstreamRequestCompression, "off">, bytes: Buffer) => CodedBytes;
+
+const defaultCompressor: Compressor = (mode, bytes) => mode === "gzip"
+  ? gzipSync(bytes, { level: 1 }) as CodedBytes
+  : zstdCompressSync(bytes, { params: { [constants.ZSTD_c_compressionLevel]: 3 } }) as CodedBytes;
+
+let compressor: Compressor = defaultCompressor;
+let maxBodyBytes = MAX_COMPRESSIBLE_BODY_BYTES;
+
+/** Test seam: replace the codec (failure injection) and the size ceiling; null restores defaults. */
+export function setUpstreamRequestCompressionForTests(next: { compressor?: Compressor | null; maxBodyBytes?: number | null }): void {
+  if (next.compressor !== undefined) compressor = next.compressor ?? defaultCompressor;
+  if (next.maxBodyBytes !== undefined) maxBodyBytes = next.maxBodyBytes ?? MAX_COMPRESSIBLE_BODY_BYTES;
+}
+
+export interface CompressedUpstreamBody {
+  body: CodedBytes;
+  encoding: Exclude<UpstreamRequestCompression, "off">;
+}
+
+/**
+ * Compress one final HTTP send body when the operator opted in and the send is eligible.
+ *
+ * Returns null — send unchanged — for any other destination, a non-string body (an already coded
+ * buffer or a stream, which also makes nested passes idempotent), a request that already declares
+ * a `content-encoding`, a body outside the size window, or a codec failure. A failure never fails
+ * the request: identity is what the proxy sent before this option existed.
+ */
+export function compressUpstreamRequestBody(
+  target: string,
+  body: unknown,
+  headers: Headers,
+  mode: UpstreamRequestCompression = currentUpstreamRequestCompression(),
+): CompressedUpstreamBody | null {
+  if (mode === "off" || typeof body !== "string" || !isCanonicalCodexResponsesUrl(target)) return null;
+  if (headers.has("content-encoding")) return null;
+  const size = Buffer.byteLength(body, "utf8");
+  if (size < MIN_COMPRESSIBLE_BODY_BYTES || size > maxBodyBytes) return null;
+  try {
+    return { body: compressor(mode, Buffer.from(body, "utf8")), encoding: mode };
+  } catch {
+    // Deliberately silent: the error could only describe the body, and identity is still correct.
+    return null;
+  }
+}

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

@@ -100,6 +100,7 @@ import type {
 import {
   codexRouteCredentialDomainHeaders,
   codexRouteCredentialOwnership,
+  mainHardLockFallbackCallerCheck,
   resolveResponsesCodexAuth,
   withClaudeNativeSession,
 } from "./core-auth";
@@ -364,7 +365,16 @@ export async function prepareResponsesRequest(
   // must run before comboIdFromRawBody reads `model`.
   if (!concreteSelection && !options.compactionRoutingOverride && !isCompactionTrigger && !options.internalDecisionCall
     && !shadowCallIntercepted && !shadowCallMatches && !memoryModelApplies && !threadSpawn && inboundWire === "responses") {
-    options.mainHardLockFallbackOverride = applyMainHardLockFallbackOverride(body, config);
+    try {
+      options.mainHardLockFallbackOverride = await applyMainHardLockFallbackOverride(
+        body, config, undefined, mainHardLockFallbackCallerCheck(req, config, options),
+      );
+    } catch (error) {
+      if (options.abortSignal?.aborted || req.signal.aborted) return clientCancelledResponse();
+      const mapped = mapCodexAuthContextErrorToResponse(error, { now: Date.now() });
+      if (mapped) return mapped;
+      throw error;
+    }
   }
   const comboId = !concreteSelection ? comboIdFromRawBody(body, config) : null;
   // A decision model may be a plain model or a non-JEV combo. A JEV combo here would recurse

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

@@ -71,7 +71,8 @@ import {
   resolveCurrentProviderApiKeyTransport,
 } from "../../providers/api-key-selection";
 import { resolveAdapter, resolveWireProtocolOverride } from "../adapter-resolve";
-import { providerFetch, sendWithConnectionPolicy } from "./fetch-helpers";
+import { codexWsExecutorBinding, physicalSendObserverInit, providerFetch, sendWithConnectionPolicy } from "./fetch-helpers";
+import { deepSeekImageFileBody, needsDeepSeekImageFiles } from "./deepseek-image-files";
 import type { ProviderFetchOptions } from "./fetch-helpers";
 import { captureConfigGeneration } from "../../lib/state-store-sweeper";
 import { recordAnthropicAccountQuotaFromHeadersForInstance, hasPassiveAccountQuota } from "../../providers/quota";
@@ -80,6 +81,7 @@ import { formatErrorResponse } from "../../bridge";
 import { bindRouteReasoningReplayScope } from "./core-replay";
 import { sessionIdHeaderFromRequest, normalizeLogConversationId } from "../request-log-conversation";
 import { redactSecretString } from "../../lib/redact";
+import { captureAccountAutoPauseAttempt } from "../../oauth/account-auto-pause";
 import { selectProactiveApiKeyTransport } from "../../providers/key-failover";
 import { distributedKeyPhysicalFetch } from "../../providers/api-key-response-ownership";
 import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers";
@@ -589,10 +591,62 @@ export async function prepareResponsesTransport(
       };
     }
     const build = resolved.buildRequest.bind(resolved);
+    const fileProvider = route.provider;
+    const fileProviderName = route.providerName;
+    // Persistence consent is configuration: capture its generation with the provider snapshot.
+    const fileConsentGeneration = captureConfigGeneration();
     resolved.buildRequest = async (requestParsed, incoming) => {
       const request = await build(requestParsed, incoming);
       // Capture at adapter creation, never from mutable serving state after an await.
       if (binding) requestBindings.set(request, binding);
+      const allowedImageFileModels = fileProvider.modelCapabilities
+        ? Object.entries(fileProvider.modelCapabilities)
+          .filter(([, cap]) => cap?.deepseekImageFiles === true)
+          .map(([model]) => model)
+        : [];
+      if (allowedImageFileModels.includes(request.outboundModelId ?? requestParsed.modelId) && needsDeepSeekImageFiles(request)) {
+        const consentModel = request.outboundModelId ?? requestParsed.modelId;
+        try {
+          // Ordinary uploads use provider pacing. A queued rebuild retains its enclosing
+          // fetch lease; reacquiring that same concurrency slot would deadlock at a limit of one.
+          const uploadFetch = providerFetch(fileProvider, options.codexWsRuntimeIdentity, {
+            httpOnly: true, providerName: fileProviderName, modelId: requestParsed.modelId,
+            beforeDispatch: () => {
+              if (!selectionIsCurrent(binding)) throw new Error("Credential selection changed before image upload");
+              // A queued upload must not outlive a revoked opt-in or a configuration reload.
+              if (captureConfigGeneration() !== fileConsentGeneration
+                || fileProvider.modelCapabilities?.[consentModel]?.deepseekImageFiles !== true) {
+                throw new Error("DeepSeek image file consent changed before image upload");
+              }
+            },
+          });
+          const uploadSignal = incoming.abortSignal ?? options.abortSignal ?? req.signal;
+          const pacedUpload: typeof fetch = incoming.dispatchPacingHeld
+            ? (async (input, init) => {
+              // The inference lease owns concurrency, but each physical upload still
+              // consumes an interval slot, including after a credential rebuild.
+              const slot = await waitForProviderRequestSlot(fileProviderName, fileProvider, requestParsed.modelId,
+                init?.signal ?? uploadSignal, { concurrency: false });
+              try { return await uploadFetch.unpacedFetch!(input, init); }
+              finally { releaseProviderRequestSlot(slot); }
+            }) as typeof fetch
+            : uploadFetch;
+          const body = await deepSeekImageFileBody(request, pacedUpload,
+            uploadSignal, {
+              allowedModels: allowedImageFileModels, budget: incoming.translatorBudget,
+            });
+          if (body !== undefined) {
+            request.releaseBodyObservation?.();
+            request.body = body;
+            const headers = new Headers(request.headers);
+            headers.delete("content-length");
+            request.headers = Object.fromEntries(headers);
+            request.releaseBodyObservation = incoming.translatorBudget.observeExternallyCapped(
+              "passthrough_serialization", Buffer.byteLength(body, "utf8"),
+            );
+          }
+        } catch (error) { request.releaseBodyObservation?.(); throw error; }
+      }
       return request;
     };
     if (resolved.runTurn) {
@@ -612,6 +666,10 @@ export async function prepareResponsesTransport(
       // Pacing may outlive admission. Preserve local pause/cooldown reasons even when
       // a strict route rejects the old proposal before another bearer can be resolved.
       let candidate = servingOAuthSnapshot;
+      if (anthropicInstance === undefined && candidate && getAccountSet(route.providerName)?.accounts.find(row => row.id === candidate!.accountId)?.paused) {
+        oauthSelection = captureOAuthAccountSelection(route.providerName);
+        candidate = oauthSelection ? await getValidAccessSnapshotForAccount(route.providerName, oauthSelection.accountId, { requireUsableAccount: true }) : undefined;
+      }
       if (anthropicInstance !== undefined) {
         oauthSelection = captureOAuthAccountSelection(route.providerName);
         const accountId = await anthropicRouting!.resolveAnthropicDispatchAccountId(config, anthropicSessionKey, anthropicRouteDecision, route.modelId);
@@ -644,6 +702,24 @@ export async function prepareResponsesTransport(
     invalidateSameTargetRequest();
     return adapter;
   };
+  const recoverAutoPausedSelection = async (requestParsed: OcxParsedRequest): Promise<boolean> => {
+    if (route.provider.authMode === "forward") return false;
+    const available = route.provider.authMode === "oauth"
+      ? getAccountSet(route.providerName)?.accounts.some(row => !row.paused && !row.needsReauth)
+      : !!config.providers[route.providerName]?.apiKey;
+    if (!available) return false;
+    await refreshDispatchAdapter(requestParsed);
+    // Bind before the recovery caller rebuilds. A terminal retry can be a clone;
+    // the outer request also owns continuation persistence and replay publication.
+    for (const replayParsed of new Set([parsed, requestParsed])) {
+      bindRouteReasoningReplayScope({
+        parsed: replayParsed, providerName: route.providerName, provider: route.provider,
+        adapterName: activeAdapter.name, oauthCredentialSnapshot: replayOAuthCredentialSnapshot,
+        forwardHeaders: requestState.selectedForwardHeaders,
+      });
+    }
+    return true;
+  };
   const refreshRunTurnAdapter = async (requestParsed: OcxParsedRequest): Promise<ProviderAdapter> => {
     requestParsed._cursorIdentityScope = undefined;
     requestParsed._cursorConversationId = undefined;
@@ -704,6 +780,7 @@ export async function prepareResponsesTransport(
           providerName: route.providerName, modelId: route.modelId, pacingSlotAcquired: true,
           pacingSlot: attemptSlot,
           turnScopedPacing: true,
+          accountAutoPause: (name, provider, headers) => captureAccountAutoPauseAttempt(name, provider, { config, oauth: binding?.kind === "oauth" ? binding.snapshot : undefined }, headers),
           beforeDispatch: beforePhysicalSend,
         });
         await run(requestParsed, { ...incoming, pacingSlot: attemptSlot, providerFetch: fetch, beforePhysicalSend }, event => { if (!refused) emit(event); });
@@ -734,7 +811,8 @@ export async function prepareResponsesTransport(
           pacingChanged = false;
         }
         if (selectionIsCurrent(requestBindings.get(wireRequest)) && copilotSessionExpiresAt > Date.now() + 1000) {
-          const fetchImpl = (route.provider as OcxProviderConfig & { fetch?: typeof globalThis.fetch }).fetch ?? execute;
+          const ws = codexWsExecutorBinding(execute);
+          const fetchImpl = (route.provider as OcxProviderConfig & { fetch?: typeof globalThis.fetch }).fetch ?? ws?.http ?? execute;
           const binding = requestBindings.get(wireRequest);
           const snapshot = anthropicInstance !== undefined && binding?.kind === "oauth"
             ? binding.snapshot : undefined;
@@ -756,6 +834,8 @@ export async function prepareResponsesTransport(
           // apply a host-scoped decision to a different host.
           const releaseFamily = snapshot ? anthropicQuota!.claimAnthropicFamilyRevalidation(snapshot.accountId, route.modelId) : () => {};
           if (!releaseFamily) throw new AnthropicAccountCooldownError(1);
+          const observeAutoPause = captureAccountAutoPauseAttempt(route.providerName, binding?.kind === "api-key" ? binding.provider : route.provider,
+            { config, oauth: binding?.kind === "oauth" ? binding.snapshot : undefined }, new Headers(dispatchInit.headers));
           let response: Response;
           let physicalOwner: AnthropicPhysicalSendOwnership | null = null;
           try {
@@ -772,10 +852,14 @@ export async function prepareResponsesTransport(
               passiveQuotaWriterGeneration = writerGeneration;
             }
             commitKeyAttemptSend();
-            response = await sendWithConnectionPolicy(
+            // The WS executor dials its own socket: HTTP connection policy and body coding do not apply.
+            // WS eligibility (egress, pacing, URL) was checked for the provider it was built for; a
+            // provider reselected above was not, so it takes the HTTP fallback under its own route.
+            response = ws?.provider === route.provider ? await execute(destination, dispatchInit) : await sendWithConnectionPolicy(
               distributedKeyPhysicalFetch(anthropicBillingPhysicalFetch(fetchImpl, route.providerName, route.provider), route.providerName, route.provider, target),
               destination,
-              { ...dispatchInit, redirect: "manual" },
+              { ...dispatchInit, redirect: "manual",
+                ...physicalSendObserverInit(observeAutoPause, destination instanceof Request ? destination.url : String(destination)) },
               { providerName: route.providerName, provider: route.provider },
             );
           } finally { releaseFamily(); }
@@ -790,11 +874,12 @@ export async function prepareResponsesTransport(
                 && current.credential.access === snapshot.accessToken
                 && credentialGeneration(current.credential) === snapshot.generation) {
                 bindAnthropicRefusalCredentialForSend(response, physicalOwner);
-                recordAnthropicAccountQuotaFromHeadersForInstance(anthropicInstance!, snapshot.accountId, response.headers, writerGeneration, response.status, route.modelId);
+                recordAnthropicAccountQuotaFromHeadersForInstance(anthropicInstance!, snapshot.accountId, response.headers, writerGeneration, response.status, route.modelId, snapshot.generation);
               }
             } catch { /* best-effort observation cannot fail the response */ }
           }
           if (!response.ok) await recordKeyAttemptFailure(logCtx, response, dispatchInit.signal ?? options.abortSignal);
+          if (observeAutoPause) response = await observeAutoPause(response);
           return response;
         }
         let nextAdapter: ProviderAdapter;
@@ -815,6 +900,7 @@ export async function prepareResponsesTransport(
           adapterName: nextAdapter.name, oauthCredentialSnapshot: replayOAuthCredentialSnapshot });
         const rebuilt = await nextAdapter.buildRequest(requestParsed, {
           headers: requestState.selectedForwardHeaders, providerName: route.providerName, translatorBudget,
+          dispatchPacingHeld: true,
           ...(imageTierBias > 0 ? { imageTierBias } : {}),
         });
         const bodySize = checkOutboundBodySize(rebuilt.body, config.maxUpstreamBodyBytes);
@@ -1280,6 +1366,7 @@ export async function prepareResponsesTransport(
     oauthDispatch,
     noteRoutedAttemptSend,
     commitKeyAttemptSend,
+    recoverAutoPausedSelection,
     bindKeyUsageFromBridge,
     anthropicSessionKey,
     isPassthrough,

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

@@ -53,6 +53,7 @@ import { emptyToolCatalogRefusal, guardEmptyToolCatalogEvents, guardEmptyToolCat
 // LOCAL PATCH (runturn-websearch)
 import { planWebSearch } from "../../web-search";
 import { runTurnWebSearchInitialParsed, runTurnWebSearchLoop } from "../../web-search/run-turn-loop";
+import { stripReplayedSearchPairs } from "../../web-search/sidecar-search-replay";
 import { WEB_SEARCH_TOOL_NAME } from "../../web-search/synthetic-tool";
 import { orderDevinMessagesOutput } from "../../claude/devin-output-order";
 import { unboundPoolSpendRefusalMessage } from "../workflow-refusal";
@@ -217,6 +218,7 @@ export async function executeResponsesRunTurn(
     releaseSearchProbeLease();
     throw error;
   }
+  if (!wsPlan) stripReplayedSearchPairs(parsed);
 
     const runTurnAbort = new AbortController();
     const cleanupRequestAbort = linkAbortSignal(runTurnAbort, req.signal);

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

@@ -39,6 +39,7 @@ import { AdmissionModelDeniedError, admissionModelDeniedResponse } from "../admi
 import { noteKiroMonthlyRefusal, noteKiroServedSuccess } from "../../providers/kiro-usage";
 import { persistKiroAccountState } from "../../providers/kiro-account-state-disk";
 import { anthropicPoolCooldownResponse, readDisplaySafeErrorText } from "./core-errors";
+import { sidecarContextOverflowResponse } from "./context-overflow";
 import {
   ANTHROPIC_POOL_MAX_FAILOVERS_PER_REQUEST,
   anthropicRoutingFor,
@@ -56,6 +57,7 @@ import { rememberResponseState } from "../../responses/state";
 import { trackStreamLifetime } from "../lifecycle";
 import { isAntigravityRawValidationRefusal } from "./antigravity-validation-refusal";
 import { createSidecarSendBudget } from "./sidecar-send-budget";
+import { stripReplayedSearchPairs } from "../../web-search/sidecar-search-replay";
 
 /** One responsibility of the Responses request pipeline; state owners are explicit. */
 export async function executeResponsesSidecars(
@@ -216,6 +218,8 @@ export async function executeResponsesSidecars(
     })
     : undefined;
   const imgPlan = !routedCompaction ? await planImageBridge(config, parsed, route.provider) : undefined;
+  // Replayed search pairs call the synthetic web_search tool only the sidecar declares (#7269).
+  if (!wsPlan) stripReplayedSearchPairs(parsed);
   const vidPlan = !routedCompaction ? await planVideoBridge(config, parsed, route.provider) : undefined;
   const canRunWebSearch = !!wsPlan && !transportState.adapter.runTurn;
   let sidecarOutputStarted = false;
@@ -548,7 +552,7 @@ export async function executeResponsesSidecars(
       options.codexWsRuntimeIdentity,
       { providerName: route.providerName, modelId: route.modelId, ...sidecarBudget.fetchOptions(transportState.adapter) },
     );
-    const imgResponse = await runWithImageBridge({
+    const imgLoopResponse = await runWithImageBridge({
       parsed, adapter: transportState.adapter,
       ...(transportState.adapter.name === "anthropic" ? { thinkingRecovery } : {}),
       clientToolCatalogRestriction: route.provider.authMode === "forward" ? undefined : requestState.clientToolCatalogRestriction,
@@ -619,8 +623,12 @@ export async function executeResponsesSidecars(
         notifyResponseComplete(response);
       },
     });
-    const imgScopeRefusal = sidecarScopeRefusal(imgResponse);
+    const imgScopeRefusal = sidecarScopeRefusal(imgLoopResponse);
     if (imgScopeRefusal) return imgScopeRefusal;
+    // A provider overflow on the first iteration answers as the main path's context failure (#7316).
+    const imgResponse = options.comboAttempt ? imgLoopResponse : sidecarContextOverflowResponse(imgLoopResponse, {
+      stream: parsed.stream, modelId: parsed._responseModelId ?? parsed.modelId, translatorBudget,
+    });
     if (imgResponse.body) {
       const imgTurnAc = new AbortController();
       imgTurnAc.signal.addEventListener("abort", cancelResponseCompletion, { once: true });
@@ -732,7 +740,12 @@ export async function executeResponsesSidecars(
       ? anthropicRoutingFor(anthropicInstance).anthropicPoolUsageLimitAfterRefusal(Date.now(), transportState.anthropicRouteDecision, route.modelId)
       : null;
     if (poolUsageLimit) void loopResponse.body?.cancel().catch(() => {});
-    const wsResponse = poolUsageLimit ? anthropicPoolCooldownResponse(poolUsageLimit, { logCtx }) : loopResponse;
+    // A provider overflow on the first iteration answers as the main path's context failure (#7316).
+    const wsResponse = poolUsageLimit ? anthropicPoolCooldownResponse(poolUsageLimit, { logCtx })
+      : options.comboAttempt ? loopResponse
+        : sidecarContextOverflowResponse(loopResponse, {
+          stream: parsed.stream, modelId: parsed._responseModelId ?? parsed.modelId, translatorBudget,
+        });
     // Register the sidecar stream as an active turn so drainAndShutdown waits for (or aborts)
     // in-flight web-search turns instead of skipping them during graceful shutdown.
     if (wsResponse.body) {

package/src/server/responses/terminal-guard.ts

@@ -170,6 +170,7 @@ export function mergeUsage(first: OcxUsage | undefined, second: OcxUsage | undef
   const cachedInputTokens = sumOptional("cachedInputTokens");
   const cacheReadInputTokens = sumOptional("cacheReadInputTokens");
   const cacheCreationInputTokens = sumOptional("cacheCreationInputTokens");
+  const cacheCreation1hInputTokens = sumOptional("cacheCreation1hInputTokens");
   const reasoningOutputTokens = sumOptional("reasoningOutputTokens");
   const providerCredits = sumOptional("providerCredits");
   const inputTokens = first.inputTokens + second.inputTokens;
@@ -181,6 +182,7 @@ export function mergeUsage(first: OcxUsage | undefined, second: OcxUsage | undef
     ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
     ...(cacheReadInputTokens !== undefined ? { cacheReadInputTokens } : {}),
     ...(cacheCreationInputTokens !== undefined ? { cacheCreationInputTokens } : {}),
+    ...(cacheCreation1hInputTokens !== undefined ? { cacheCreation1hInputTokens } : {}),
     ...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),
     ...(providerCredits !== undefined ? { providerCredits } : {}),
     ...(first.estimated || second.estimated ? { estimated: true } : {}),

package/src/server/startup-action-control.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { execFile } from "node:child_process";
 import { join } from "node:path";
-import { durableBunPath } from "../lib/bun-runtime";
+import { durableBunChildEnv, durableBunPath } from "../lib/bun-runtime";
 import { selfLaunchArgv } from "../lib/self-launch-argv";
 import { isDesktopSupervised } from "../lib/system-restart-contract";
 import { withLoginShellPath } from "./login-shell-path";
@@ -196,7 +196,7 @@ async function runCliInstall(
     isStandaloneExecutable: installLaunch.isStandaloneExecutable,
   });
   const run = installLaunch.execFile ?? execFile;
-  const env = await installChildEnv(action);
+  const env = durableBunChildEnv(await installChildEnv(action));
   return new Promise((resolve, reject) => {
     const timeout = process.platform === "win32" && action === "install-service"
       ? 0

package/src/server/startup-health-cache.ts

@@ -4,7 +4,7 @@ import { codexAutoStartEnabled } from "../config";
 import { deriveStartupHealth, startupHealthProbeBudgetMs, type StartupHealth } from "../codex/autostart-health";
 import { getCodexRoutingKind } from "../codex/inject";
 import { diagnoseCodexShim } from "../codex/shim";
-import { durableBunPath } from "../lib/bun-runtime";
+import { durableBunChildEnv, durableBunPath } from "../lib/bun-runtime";
 import { selfLaunchArgv } from "../lib/self-launch-argv";
 import { desktopStartupOwnership } from "../service/desktop-startup";
 import type { OcxConfig } from "../types";
@@ -129,7 +129,7 @@ function runProbe(config: Pick<OcxConfig, "codexAutoStart">): Promise<StartupHea
   return new Promise(resolve => {
     execFile(bun, selfLaunchArgv(["__startup-health"], { sourceEntrypoint: cli }), {
       encoding: "utf8",
-      env: process.env,
+      env: durableBunChildEnv(process.env),
       timeout: PROBE_TIMEOUT_MS,
       windowsHide: true,
       maxBuffer: 256 * 1024,

package/src/server/windows-tray-control.ts

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { join } from "node:path";
-import { durableBunPath } from "../lib/bun-runtime";
+import { durableBunChildEnv, durableBunPath } from "../lib/bun-runtime";
 import type { WindowsTrayStatus } from "../tray/windows";
 
 export type WindowsTrayAction = "install" | "start" | "stop" | "status" | "uninstall";
@@ -15,7 +15,7 @@ export function runWindowsTrayAction(action: WindowsTrayAction): Promise<Windows
   return new Promise((resolve, reject) => {
     execFile(bun, [cli, "tray", action, "--json"], {
       encoding: "utf8",
-      env: process.env,
+      env: durableBunChildEnv(process.env),
       timeout: 30_000,
       windowsHide: true,
       maxBuffer: 256 * 1024,

package/src/service/definition.ts

@@ -90,8 +90,16 @@ export function parseBakedListenPort(read: () => string): number | null {
 export function resolvedProxyEnv(env: NodeJS.ProcessEnv = process.env): { name: string; value: string }[] {
   const resolved: { name: string; value: string }[] = [];
   for (const key of PROXY_ENV_KEYS) {
-    const value = env[key]?.trim() || env[key.toLowerCase()]?.trim();
+    const value = [env[key]?.trim(), env[key.toLowerCase()]?.trim()].find(v => v && !OWN_CLAUDE_INTERCEPT_PROXY.test(v));
     if (value) resolved.push({ name: key, value });
   }
   return resolved;
 }
+
+/**
+ * The URL Claude first-party writes into `~/.claude/settings.json` (`claudeInterceptProxyUrl`),
+ * which every process Claude Code starts inherits. Baked into the service, it would send the
+ * proxy's own outbound traffic back through its intercept listener. Only the token-bearing form
+ * is matched: a plain `http://127.0.0.1:<port>` is a user's local proxy client and is kept.
+ */
+const OWN_CLAUDE_INTERCEPT_PROXY = /^http:\/\/opencodex:[^@/]+@127\.0\.0\.1:\d{1,5}\/?$/i;

package/src/service/orchestration.ts

@@ -238,6 +238,11 @@ export interface ServiceInstallPreparationDeps extends RuntimePreflightDeps {
   supervisionLatch?: SupervisionLatch;
   diagnose?: () => ServiceDiagnostic;
   managerOps?: (backend: ServiceBackend) => ServiceInstallCleanupOps | null;
+  /**
+   * Task Scheduler only: ends surviving launcher/wrapper processes of THIS
+   * installation. Scoped to canonical script/launcher tokens, never a bare PID.
+   */
+  killServiceWrappers?: () => void;
   stopTrackedProxy?: () => Promise<unknown>;
   platform?: NodeJS.Platform;
 }
@@ -279,6 +284,18 @@ export async function prepareServiceInstall(
     if (!manager) throw new Error(`Background service manager is unavailable for ${backend}.`);
     if (manager.status() !== null) manager.stop();
   }
+  if (platform === "win32") {
+    // `schtasks /end` ends the task instance but leaves the cmd `:loop` wrapper
+    // alive to respawn the proxy mid-install — the same survivor
+    // `ocx stop` kills via killWindowsServiceWrapperProcesses. Run it
+    // after every manager has been asked to stop and before the tracked-proxy
+    // kill so a child respawned in that gap is still caught below. It also runs
+    // when no manager stop happened: a registration deleted mid-uninstall can
+    // leave the detached wrapper looping. A manager stop that refused propagates
+    // above before this runs, so the respawner of a still-running service is
+    // never killed.
+    (deps.killServiceWrappers ?? killWindowsServiceWrapperProcesses)();
+  }
   await (deps.stopTrackedProxy ?? stopTrackedProxyIfRunning)();
 }
 

package/src/types/account-auto-pause.ts

@@ -0,0 +1,15 @@
+export const ACCOUNT_PAUSE_REASONS = [
+  "oauth_organization_disabled", "account_permission_denied", "subscription_inactive",
+  "subscription_expired", "plan_downgraded",
+] as const;
+export type AccountPauseReason = typeof ACCOUNT_PAUSE_REASONS[number];
+export interface AccountPauseDetails {
+  reason: AccountPauseReason;
+  pausedAt: number;
+}
+export interface AccountAutoPausePolicy {
+  /** Explicit opt-in. Omitted and false both leave account eligibility unchanged. */
+  enabled?: boolean;
+  /** Consecutive permanent refusals; defaults to 2. */
+  consecutiveFailures?: number;
+}