@bitkyc08/opencodex 2.87.0 → 2.89.0

package/src/responses/reasoning-replay-cache.ts

@@ -46,6 +46,7 @@ export function nativeReasoningTagMatches(expected: string | undefined, presente
 const MAX_TOTAL_BYTES = 256 * 1024;
 const TTL_MS = 60 * 60 * 1000;
 const OPAQUE_BLOB_REJECTION_TTL_MS = 5 * 60 * 1000;
+const MAX_OPAQUE_BLOB_REJECTION_FINGERPRINTS = 256;
 const replayIdentityKey = randomBytes(32);
 const CREDENTIAL_HEADER_NAMES = new Set([
   "authorization",
@@ -78,8 +79,14 @@ interface ServingIdentityEntry {
 interface OpaqueBlobRejectionEntry {
   bytes: number;
   at: number;
+  /** Undefined retains the legacy blanket rejection; only payload digests are stored here. */
+  fingerprints?: ReadonlySet<string>;
 }
 
+export type ReasoningReplayOpaqueBlobRejection =
+  | { mode: "blanket" }
+  | { mode: "selective"; fingerprints: ReadonlySet<string> };
+
 const entries = new Map<string, CacheEntry>();
 const servingIdentities = new Map<string, ServingIdentityEntry>();
 const opaqueBlobRejections = new Map<string, OpaqueBlobRejectionEntry>();
@@ -310,18 +317,57 @@ export function reasoningReplayOpaqueBlobRejectionMemoized(
   return opaqueBlobRejections.has(key);
 }
 
+/** Undefined means no live memo; a selective result owns a defensive copy of its digests. */
+export function getReasoningReplayOpaqueBlobRejection(
+  scope: OcxReasoningReplayScopeRef | undefined,
+): ReasoningReplayOpaqueBlobRejection | undefined {
+  const key = opaqueBlobRejectionKeyFor(scope);
+  if (!key) return undefined;
+  sweepExpiredOpaqueBlobRejections(now());
+  const entry = opaqueBlobRejections.get(key);
+  return entry === undefined ? undefined : entry.fingerprints === undefined ? { mode: "blanket" }
+    : { mode: "selective", fingerprints: new Set(entry.fingerprints) };
+}
+
+/** Incomplete, invalid or unbounded enumerations cannot safely narrow the legacy rejection. */
+function boundedRejectionFingerprints(fingerprints: ReadonlySet<string> | undefined): Set<string> | undefined {
+  if (fingerprints === undefined) return undefined;
+  const copy = new Set<string>();
+  try {
+    // The intrinsic validates a real Set without trusting an overridden iterator or size getter.
+    for (const value of Set.prototype.values.call(fingerprints) as IterableIterator<unknown>) {
+      if (typeof value !== "string" || value.length !== 64 || !/^[a-f0-9]{64}$/.test(value)
+        || copy.size >= MAX_OPAQUE_BLOB_REJECTION_FINGERPRINTS) return undefined;
+      copy.add(value);
+    }
+  } catch { return undefined; }
+  return copy.size > 0 ? copy : undefined;
+}
+
 /** Record only after a blobless retry succeeded for this durable serving identity. */
 export function rememberReasoningReplayOpaqueBlobRejection(
   scope: OcxReasoningReplayScopeRef | undefined,
+  fingerprints?: ReadonlySet<string>,
 ): void {
   const key = opaqueBlobRejectionKeyFor(scope);
   if (!key) return;
-  const bytes = Buffer.byteLength(key, "utf8");
-  if (bytes > MAX_TOTAL_BYTES) return;
+  const keyBytes = Buffer.byteLength(key, "utf8");
+  if (keyBytes > MAX_TOTAL_BYTES) return;
   const at = now();
   sweepExpiredOpaqueBlobRejections(at);
-  if (opaqueBlobRejections.has(key)) deleteOpaqueBlobRejection(key);
-  opaqueBlobRejections.set(key, { bytes, at });
+  const previous = opaqueBlobRejections.get(key);
+  let merged = previous && previous.fingerprints === undefined ? undefined : boundedRejectionFingerprints(fingerprints);
+  if (merged && previous?.fingerprints) {
+    for (const fingerprint of previous.fingerprints) {
+      merged.add(fingerprint);
+      if (merged.size > MAX_OPAQUE_BLOB_REJECTION_FINGERPRINTS) { merged = undefined; break; }
+    }
+  }
+  // A near-limit key can still retain its existing blanket memo if the digest set will not fit.
+  if (merged && keyBytes + merged.size * 64 > MAX_TOTAL_BYTES) merged = undefined;
+  const bytes = keyBytes + (merged?.size ?? 0) * 64;
+  if (previous) deleteOpaqueBlobRejection(key);
+  opaqueBlobRejections.set(key, { bytes, at, ...(merged ? { fingerprints: merged } : {}) });
   opaqueBlobRejectionTotalBytes += bytes;
   while (
     (opaqueBlobRejectionTotalBytes > MAX_TOTAL_BYTES || opaqueBlobRejections.size > MAX_ENTRIES)

package/src/responses/web-search-replay.ts

@@ -0,0 +1,138 @@
+/**
+ * Parse-time rebuild of replayed hosted `web_search_call` cells for routed providers (#7269).
+ *
+ * Codex replays the cell it was shown, which carries the query and at most a source list, never the
+ * result text. Dropping the cell made a routed model forget it had searched: after a client tool
+ * call ended the turn, the next request carried no trace of the search, so the model searched and
+ * ran its tools again in a loop.
+ *
+ * When search is declared, the parser rewrites each cell into the `web_search` function call and
+ * output the routed model made, at the raw-input level, so the ordinary call/output handling owns
+ * turn batching and reasoning attachment. The call takes the cell's place; its output is deferred to
+ * the end of the contiguous run of call/output items that follows, so a cell inside a parallel
+ * client batch never splits it. The output is a fallback built from the cell alone; the web-search
+ * sidecar swaps in the result it recorded for the cell, and removes the pairs again when it does not
+ * run, because the synthetic tool is then undeclared (src/web-search/sidecar-search-replay.ts).
+ */
+import { isObj } from "./parser-content";
+import { WEB_SEARCH_TOOL_NAME } from "../web-search/synthetic-tool";
+import type { OcxReplayedWebSearchCell } from "../types";
+
+const MAX_FIELD_CHARS = 2048;
+const MAX_LIST_ENTRIES = 20;
+const CELL_ID = /^[A-Za-z0-9_-]{1,128}$/;
+
+/** Call items of a batch; a call after the batch's first output starts the next assistant turn. */
+const CALL_TYPES = new Set(["function_call", "custom_tool_call", "local_shell_call", "tool_search_call"]);
+/** Output items of a batch. Anything that is neither a call nor an output ends the batch. */
+const OUTPUT_TYPES = new Set(["function_call_output", "custom_tool_call_output", "local_shell_call_output", "tool_search_output"]);
+
+function capped(value: string): string {
+  return value.length <= MAX_FIELD_CHARS ? value : `${value.slice(0, MAX_FIELD_CHARS)}…`;
+}
+
+function queriesOf(action: Record<string, unknown>): string[] {
+  const queries = Array.isArray(action.queries)
+    ? action.queries.filter((query): query is string => typeof query === "string" && query.trim() !== "")
+    : [];
+  if (queries.length === 0 && typeof action.query === "string" && action.query.trim() !== "") queries.push(action.query);
+  return queries.slice(0, MAX_LIST_ENTRIES).map(capped);
+}
+
+function sourcesOf(item: Record<string, unknown>, action: Record<string, unknown>): string[] {
+  const lines: string[] = [];
+  const seen = new Set<string>();
+  for (const list of [item.sources, action.sources]) {
+    if (!Array.isArray(list)) continue;
+    for (const source of list) {
+      if (lines.length >= MAX_LIST_ENTRIES) return lines;
+      if (!isObj(source) || typeof source.url !== "string" || seen.has(source.url)) continue;
+      seen.add(source.url);
+      lines.push(typeof source.title === "string" && source.title.trim() !== ""
+        ? `- ${capped(source.title)} <${capped(source.url)}>`
+        : `- <${capped(source.url)}>`);
+    }
+  }
+  return lines;
+}
+
+/** The call arguments and fallback result text for one replayed cell. */
+export function replayedWebSearchContent(item: Record<string, unknown>): { arguments: Record<string, unknown>; result: string; failed: boolean } {
+  const action = isObj(item.action) ? item.action : {};
+  const failed = item.status === "failed";
+  const queries = queriesOf(action);
+  const lines: string[] = [];
+  if (action.type === "open_page" && typeof action.url === "string") {
+    lines.push(`Earlier page open: <${capped(action.url)}>.`);
+  } else if (action.type === "find_in_page" && typeof action.url === "string") {
+    lines.push(`Earlier find in page <${capped(action.url)}>${typeof action.pattern === "string" ? ` for "${capped(action.pattern)}"` : ""}.`);
+  } else {
+    lines.push(queries.length > 0 ? `Earlier web search for: ${queries.map(query => `"${query}"`).join(", ")}.` : "Earlier web search.");
+  }
+  if (failed) {
+    lines.push("This search failed and returned no results.");
+  } else {
+    lines.push("The result text of this search is not available in the replayed conversation history.");
+    const sources = sourcesOf(item, action);
+    if (sources.length > 0) lines.push("Sources it returned (titles and URLs only, untrusted):", ...sources);
+  }
+  return { arguments: queries.length > 1 ? { queries } : { query: queries[0] ?? "" }, result: lines.join("\n"), failed };
+}
+
+export interface RewrittenWebSearchInput {
+  items: unknown[];
+  /** Original input index per rewritten item, for boundaries measured on the caller's input. */
+  sourceIndexes: number[];
+  cells: OcxReplayedWebSearchCell[];
+}
+
+/** Rewrite replayed cells into web_search call/output pairs; undefined when the input has none. */
+export function rewriteReplayedWebSearchCells(input: readonly unknown[]): RewrittenWebSearchInput | undefined {
+  if (!input.some(item => isObj(item) && item.type === "web_search_call")) return undefined;
+  // A synthetic call id must not collide with any client call id, nor with another cell's.
+  const taken = new Set(input.flatMap(item => isObj(item) && typeof item.call_id === "string" ? [item.call_id] : []));
+  const allocate = (base: string): string => {
+    let id = base;
+    for (let n = 1; taken.has(id); n++) id = `${base}_${n}`;
+    taken.add(id);
+    return id;
+  };
+  const items: unknown[] = [];
+  const sourceIndexes: number[] = [];
+  const cells: OcxReplayedWebSearchCell[] = [];
+  const seenCells = new Set<string>();
+  let pending: Array<{ item: unknown; sourceIndex: number }> = [];
+  // True once the current batch reached its outputs: the next call opens a new assistant turn.
+  let outputPhase = false;
+  const flush = () => {
+    for (const entry of pending) { items.push(entry.item); sourceIndexes.push(entry.sourceIndex); }
+    pending = [];
+    outputPhase = false;
+  };
+  input.forEach((item, sourceIndex) => {
+    const type = isObj(item) ? item.type : undefined;
+    if (isObj(item) && type === "web_search_call") {
+      const cellId = typeof item.id === "string" && CELL_ID.test(item.id) ? item.id : undefined;
+      // The same cell replayed twice is one search.
+      if (cellId && seenCells.has(cellId)) return;
+      if (cellId) seenCells.add(cellId);
+      if (outputPhase) flush();
+      const content = replayedWebSearchContent(item);
+      const callId = allocate(cellId ?? "ws_replay");
+      cells.push({ ...(cellId ? { cellId } : {}), callId, failed: content.failed });
+      items.push({ type: "function_call", call_id: callId, name: WEB_SEARCH_TOOL_NAME, arguments: JSON.stringify(content.arguments) });
+      sourceIndexes.push(sourceIndex);
+      pending.push({ item: { type: "function_call_output", call_id: callId, output: content.result }, sourceIndex });
+      return;
+    }
+    if (typeof type === "string" && OUTPUT_TYPES.has(type)) {
+      outputPhase = true;
+    } else if (!(typeof type === "string" && CALL_TYPES.has(type)) || outputPhase) {
+      flush();
+    }
+    items.push(item);
+    sourceIndexes.push(sourceIndex);
+  });
+  flush();
+  return { items, sourceIndexes, cells };
+}

package/src/routing/analytics.ts

@@ -12,7 +12,7 @@
  */
 
 import type { PersistedUsageEntry } from "../usage/log";
-import { estimateRequestCost, serviceTierContext } from "../usage/cost";
+import { computeEntryCost } from "../usage/summary";
 import { openRequestHistoryIndex, requestHistoryDb } from "./history/indexer";
 
 export const ANALYTICS_MAX_ROWS = 50_000;
@@ -122,6 +122,7 @@ const COOLDOWN_RECOVERY_KINDS = new Set([
   "oauth-account-403",
   "anthropic-oauth-429",
   "oauth-account-429",
+  "oauth-account-402",
 ]);
 
 function percentile(sorted: number[], p: number): number | undefined {
@@ -158,19 +159,10 @@ function cooldownTriggering(entry: PersistedUsageEntry | null, status: number):
   });
 }
 
-function successCostUsd(
-  row: Pick<ScannedRow, "provider" | "model">,
-  entry: PersistedUsageEntry,
-): number | null {
-  if (!entry.usage) return null;
-  const estimate = estimateRequestCost({
-    provider: row.provider,
-    model: row.model,
-    usage: entry.usage,
-    usageStatus: entry.usageStatus,
-    serviceTier: serviceTierContext(entry),
-  });
-  return estimate ? estimate.cost.total : null;
+/** Same attempt-aware pricing as /api/usage, so a refused retry before a measured send is priced. */
+function successCostUsd(entry: PersistedUsageEntry): number | null {
+  const { isPriced, costTotal } = computeEntryCost(entry);
+  return isPriced ? costTotal : null;
 }
 
 export async function computeRoutingAnalytics(
@@ -245,7 +237,7 @@ export async function computeRoutingAnalytics(
     if (kind === "success") {
       const entry = parseEntry(row.rowJson);
       if (entry) {
-        rowCostUsd = successCostUsd(row, entry);
+        rowCostUsd = successCostUsd(entry);
         if (rowCostUsd !== null) {
           costTotalUsd += rowCostUsd;
           costCount += 1;

package/src/routing/compatibility/behavior.ts

@@ -4,6 +4,7 @@ import type { OcxConfig, OcxProviderConfig } from "../../types";
 import { PROVIDER_REGISTRY } from "../../providers/registry";
 import { fastPolicyForModel, serviceTierSupportFromPolicy } from "../../providers/service-tier";
 import { resolveProviderAuthTransport } from "../../providers/fastwire";
+import { defaultAnthropicCacheRetention } from "../../adapters/anthropic/cache-retention";
 import { localFingerprint } from "../../lab/digest";
 import type { LabBehaviorSource, LabBehaviorValues } from "../../lab/live/types";
 
@@ -237,7 +238,9 @@ export function resolveProductionBehaviorValues(
     }),
     "tools.builtinNameEscaping": behaviorRow("provider_config", effective.escapeBuiltinToolNames === true),
     "cache.forwarding": behaviorRow("provider_config", effective.promptCacheKey === true),
-    "cache.retention": behaviorRow("global_config", config.cacheRetention ?? "short"),
+    // The wire TTL, not just the setting: an omitted value means 1h on first-party Anthropic.
+    "cache.retention": behaviorRow("global_config", config.cacheRetention
+      ?? (adapter === "anthropic" ? defaultAnthropicCacheRetention(effective) : "short")),
     "anthropic.eofPolicy": behaviorRow("provider_config", effective.anthropicEofTolerance === true ? "tolerant" : "strict"),
     "openai-chat.eofPolicy": behaviorRow("provider_config", effective.openaiChatEofTolerance === true ? "tolerant" : "strict"),
     "google.mode": behaviorRow("provider_config", effective.googleMode ?? null),

package/src/server/auth-cors.ts

@@ -40,6 +40,7 @@ import { DECLARABLE_HOSTED_TOOL_TYPES } from "../responses/hosted-tool-policy";
 import { effectiveGoogleMode, getProviderRegistryEntry, providerCodexAccountMode, providerMatchesRegistryTransport, registryEntryForProviderDestination } from "../providers/registry";
 import { providerConfigSeed } from "../providers/derive";
 import { anthropicOAuthInstanceConfigError } from "../config/schema/anthropic-account-pool";
+import { accountAutoPausePolicySchema } from "../config/schema/account-auto-pause";
 import type { OcxConfig, OcxProviderConfig } from "../types";
 import { openRouterRoutingConfigError } from "../providers/openrouter-routing";
 import { modelAutoCompactTokenLimitsConfigError } from "../providers/auto-compact-budget";
@@ -740,6 +741,9 @@ export function providerManagementConfigError(
     return "provider must be a plain object";
   }
   const raw = provider as Record<string, unknown>;
+  if (raw.accountAutoPause !== undefined && !accountAutoPausePolicySchema.safeParse(raw.accountAutoPause).success) {
+    return "accountAutoPause must be an object with optional boolean enabled and integer consecutiveFailures (1-100)";
+  }
   const contextTiersError = contextTierRecordConfigError(raw.modelContextTiers);
   if (contextTiersError) return contextTiersError;
   const capabilitiesError = modelCapabilitiesConfigError(raw.modelCapabilities);
@@ -796,6 +800,8 @@ export function providerManagementConfigError(
     // sends recover, not what the canonical forward seed is. Validated below
     // (retryOnResetPolicyConfigError).
     delete canonicalCandidate.retryOnReset;
+    // Validated account eligibility policy is independent of the canonical transport.
+    delete canonicalCandidate.accountAutoPause;
     // Context windows are the same kind of user-owned overlay as requestPacing: the operator
     // narrowing what their own native rows advertise. They can only ever LOWER the measured
     // window (see nativeOpenAiContextWindow), so admitting them cannot widen what the proxy
@@ -1087,6 +1093,7 @@ const PROVIDER_CONFIG_FIELD_POLICY = {
   apiKeyPool: "redacted",
   // Ordering preference only; it names no key material, so an editor may read and set it.
   apiKeyPoolStrategy: "editor",
+  accountAutoPause: "editor",
   apiKeySelectionRevision: "runtime",
   _apiKeyAttempt: "runtime",
   defaultModel: "editor",

package/src/server/background-lifecycle.ts

@@ -1,5 +1,6 @@
 import type { OcxConfig, StorageCleanupPolicy } from "../types";
 import { registerCodexLowQuotaProtection, type LowQuotaRegistration } from "../codex/low-quota-protection";
+import { resolveLowQuotaDesktopSink } from "../codex/low-quota-desktop-notifier";
 import type { LowQuotaEvent } from "../codex/low-quota-events";
 import { startStateStoreSweeper } from "../lib/state-store-sweeper";
 import {
@@ -209,7 +210,7 @@ export function acquireServerBackgroundLifecycle(
     fanoutRevoked: false,
     applyPolicy,
     resources: acquireServerResourceOwner(),
-    lowQuota: registerCodexLowQuotaProtection(config),
+    lowQuota: registerCodexLowQuotaProtection(config, { desktopSink: () => resolveLowQuotaDesktopSink() }),
   };
   try {
     if (!processLoops) {

package/src/server/chat-native.ts

@@ -1,3 +1,4 @@
+import { captureAccountAutoPauseAttempt, wasAccountAutoPaused } from "../oauth/account-auto-pause";
 import { createPhysicalSendReporter } from "../lib/request-execution-budget";
 import { createInferenceSendBudget } from "./inference/context";
 import { observeAdvisorNativeReasoning } from "./inference/advisor-diagnostics";
@@ -64,11 +65,10 @@ import { RequestPacingQueueOverloadError } from "../providers/request-pacing";
 import { stampApiKeyAccountLabel } from "../providers/label";
 import { distributedKeyPhysicalFetch, distributedKeyResponseOwner } from "../providers/api-key-response-ownership";
 import { providerApiKeySelectionIsCurrent, resolveCurrentProviderApiKeyTransport } from "../providers/api-key-selection";
-import { enrichOpenCodeZenFreeTierMessage } from "../providers/opencode-zen-rate-limit";
 import type { OcxProviderTransport } from "../providers/xai-transport";
 import type { RouteResult } from "../router";
 import type { OcxConfig, OcxProviderConfig } from "../types";
-import { fetchWithHeaderTimeout, providerFetch, safeHostLabel, sendWithConnectionPolicy } from "./responses/fetch-helpers";
+import { fetchWithHeaderTimeout, physicalSendObserverInit, providerFetch, safeHostLabel, sendWithConnectionPolicy } from "./responses/fetch-helpers";
 import { isLocalUpstream } from "../lib/local-upstream";
 import { linkAbortSignal } from "./responses";
 import {
@@ -449,7 +449,7 @@ export async function runNativeChatAttempt(
   let responseOwnsDistributedKey = true;
   const send = async (
     request: AdapterRequest,
-    recovery?: "rate-limit-429" | "key-429" | "key-401" | UpstreamSendRecovery,
+    recovery?: "rate-limit-429" | "key-401" | "key-429" | UpstreamSendRecovery,
     singleShot = false,
   ): Promise<Response> => {
     try {
@@ -516,6 +516,7 @@ export async function runNativeChatAttempt(
               const spendReport = createPhysicalSendReporter(physicalBudget, () => ({
                 poolId: logCtx.spendPoolId ?? route.providerName, identityId: logCtx.accountLogLabel,
               }), execution.comboDispatchPermit);
+              const observeAutoPause = captureAccountAutoPauseAttempt(route.providerName, activeProvider, { config, oauth: undefined }, headers);
               let dispatched: Response;
               try {
                 // Capture this request's spend policy at its first physical boundary, including
@@ -538,6 +539,7 @@ export async function runNativeChatAttempt(
                   request.url,
                   applyUpstreamRecoveryInit({
                     ...init, method: request.method, headers, body: request.body,
+                    ...physicalSendObserverInit(observeAutoPause, request.url),
                   }, transportRecovery),
                   // Reselection can replace the provider transport and the wire shape, so the
                   // egress route is bound to the provider this send actually uses. Omitting it
@@ -552,7 +554,7 @@ export async function runNativeChatAttempt(
               responseOwnsDistributedKey = !activeProvider._apiKeyAttempt?.distributed
                 || distributedKeyResponseOwner(dispatched, config, route.providerName) !== null;
               if (!dispatched.ok) await recordKeyAttemptFailure(logCtx, dispatched, init.signal ?? upstream.signal);
-              return dispatched;
+              return observeAutoPause ? observeAutoPause(dispatched) : dispatched;
             },
           }),
         );
@@ -585,6 +587,23 @@ export async function runNativeChatAttempt(
     response = await send(activeRequest);
     const retryPolicy = rateLimitRetryPolicyFor(activeProvider);
     let retries = 0;
+    let autoPauseMoves = 0;
+    for (;;) {
+      const priorResponse = response;
+      for (; wasAccountAutoPaused(response) && config.providers[route.providerName]?.apiKey && autoPauseMoves < 3 && transientSendAvailable(); autoPauseMoves++) {
+        const fresh = resolveCurrentProviderApiKeyTransport(config, route.providerName, { ...activeProvider, _apiKeyAttempt: undefined });
+        const next = fresh && (selectProactiveApiKeyTransport(config, route.providerName, fresh) ?? fresh);
+        if (!next) break;
+        try { void response.body?.cancel().catch(() => {}); } catch { /* closed */ }
+        activeProvider = next;
+        stampApiKeyAccountLabel(logCtx, route.providerName, activeProvider);
+        activeAdapter = createOpenAIChatAdapter(activeProvider);
+        releaseRetainedRequest();
+        activeRequest = buildActiveRequest();
+        retainRequest(activeRequest);
+        response = await send(activeRequest, "key-401");
+      }
+
     while (
       response.status === 429
       // A 429 this proxy synthesized for a refused reset replay is not a provider rate
@@ -632,6 +651,10 @@ export async function runNativeChatAttempt(
       retainRequest(activeRequest);
       response = await send(activeRequest, failureStatus === 401 ? "key-401" : "key-429");
     }
+      if (response !== priorResponse && wasAccountAutoPaused(response)) continue;
+      break;
+    }
+
   } catch (error) {
     releaseRetainedRequest();
     cleanupAbort();
@@ -694,20 +717,12 @@ export async function runNativeChatAttempt(
       && (isCyberPolicyCode(upstreamCode) || isCyberPolicyMessage(upstreamMessage))
       ? upstreamMessage
       : detail ? `Provider error ${response.status}: ${detail}` : `Provider error ${response.status}`;
-    // Zen's keyless free tier refuses the request outright rather than rate-limiting it, and
-    // the raw `MissingSessionID` tells a user nothing about why or what to do (#4121).
-    const clientMessage = enrichOpenCodeZenFreeTierMessage(message, {
-      providerName: route.providerName,
-      baseUrl: route.provider.baseUrl,
-      adapter: route.provider.adapter,
-      upstreamErrorType: upstreamType,
-    });
     const classified = classifyError(
       response.status,
       upstreamType ?? (response.status === 401 ? "authentication_error"
         : response.status === 429 ? "rate_limit_error"
           : response.status >= 500 ? "server_error" : "invalid_request_error"),
-      clientMessage,
+      message,
     );
     // The verdict is read once, from the response that carries it and from the code a
     // re-wrapped body kept -- never from the status, which a real rate limit shares.

package/src/server/claude-messages.ts

@@ -33,7 +33,7 @@ import { resolveAlias, claudeCodeNativeAlias, legacyAliasForNative } from "../cl
 import { recordDesktopRequest } from "../claude/desktop-health";
 import { stripOneMillionMarker } from "../claude/context-windows";
 import { captureClaudeInbound } from "../claude/inbound-debug";
-import { declaredAnthropicServerTools } from "../claude/inbound-content-options";
+import { declaredAnthropicServerTools, replayedAnthropicServerBlocks } from "../claude/inbound-content-options";
 import { claudeCodeForIngress } from "../claude/intercept/model-bindings";
 import { classifyInterceptClient } from "../claude/intercept/client-class";
 import { analyzeClaudeCompatibility, isClaudeCompatibilityMode } from "../claude/compatibility";
@@ -1110,7 +1110,8 @@ async function handleClaudeMessagesWithBudget(
   const finalizeNativeLog = createFinalRequestLog(logIds, logCtx).finish;
   const upstream = await handleResponses(internalReq, {
     ...buildClaudeReplayConfig(config),
-    // Operator config wins; otherwise the caller's own 1h breakpoints keep 1h here.
+    // Operator config wins; otherwise the caller's explicit TTLs (all 1h, or a pinned 5m) carry
+    // over, and TTL-less breakpoints take the destination default.
     cacheRetention: config.cacheRetention ?? callerCacheRetention(anthropicBody),
   }, logCtx, {
     // Routing keeps Claude-only sidecar overrides; admission policy must follow the live owner.
@@ -1133,6 +1134,7 @@ async function handleClaudeMessagesWithBudget(
     nativeReasoningMint,
     // Out of body like the replay above: the core hands these to an Anthropic destination only.
     anthropicServerTools: declaredAnthropicServerTools(anthropicBody),
+    anthropicServerReplay: replayedAnthropicServerBlocks(anthropicBody),
     claudeGoAffinity: { sessionLane: claudeGoSessionLane },
     claudeNativeSessionId,
     stripClaudeMainAuthForNoncanonicalForward: true,

package/src/server/index/live-sideband.ts

@@ -40,8 +40,9 @@ export const MAX_WS_FRAME_BYTES = 50 * 1024 * 1024;
  *
  * What must never happen is neither: an immortal socket plus a destination that silently accepts
  * the orphaned delta. `tests/responses/ws-endpoint.test.ts` holds exactly that pair together.
- * Raising the timeout off 0 is still worth doing for its own reasons (a dead peer holds a socket
- * forever today), and Bun caps the value at 255 seconds, well inside the bound below.
+ * Responses admission separately reclaims its least recently used idle connection under
+ * capacity pressure. That is not a time limit, so expired-reference validation remains required.
+ * Keeping this shared timeout at 0 also preserves quiet live/voice sessions.
  */
 export const WEBSOCKET_IDLE_TIMEOUT_SECONDS = 0;
 /** Ceiling a finite websocket idle timeout must stay under, in seconds. See above. */

package/src/server/index/optional-listeners.ts

@@ -17,6 +17,7 @@ import { createLinkSupervisor, type LinkSupervisor } from "../../link/supervisor
 import { linkManagementRouteAllowed } from "../../link/management-routes";
 import { saveConfigPreservingClaudeCode } from "../../config/live-reconcile";
 import { reconcileLiveStateStores } from "../../lib/state-store-registrations";
+import { startJevQuotaActivation } from "../../combos/jev-quota-activation";
 export { LINK_INGRESS_HOSTNAME } from "./link-listener";
 import type { ServerIngress } from "./serve-options";
 
@@ -51,6 +52,7 @@ export function createOptionalListenerSet<T>(linkDeps: LinkListenerDeps = {}): O
   const claudeIntercept: ClaudeInterceptLifecycle<T> = createClaudeInterceptLifecycle<T>();
   const linkListener: LinkListenerLifecycle<T> = createLinkListenerLifecycle<T>(linkDeps);
   let activeConfig: OcxConfig | undefined;
+  let stopJevQuotaActivation: (() => void) | undefined;
   const supervisor = createLinkSupervisor({
     apiKeys: () => activeConfig?.apiKeys ?? [],
     revokeApiKey: id => {
@@ -114,6 +116,8 @@ export function createOptionalListenerSet<T>(linkDeps: LinkListenerDeps = {}): O
         maxRequestBodySize: ctx.maxRequestBodySize,
         dispatch: ctx.dispatch,
       });
+      // Last, after every listener started: JEV advisory quota follows the live config while serving.
+      stopJevQuotaActivation = startJevQuotaActivation(ctx.config);
     },
     ensureStarted: () => linkListener.ensureStarted(),
     close: () => linkListener.close(),
@@ -132,6 +136,8 @@ export function createOptionalListenerSet<T>(linkDeps: LinkListenerDeps = {}): O
       try { await claudeIntercept.stop(); } catch (error) { failure ??= error; }
       unregisterSupervisorAdmission?.();
       unregisterSupervisorAdmission = undefined;
+      stopJevQuotaActivation?.();
+      stopJevQuotaActivation = undefined;
       if (failure) throw failure;
     },
   };

package/src/server/index/serve-options.ts

@@ -1618,11 +1618,17 @@ export function createServeOptions(ctx: ServeOptionsContext) {
         // Promote a caller `x-session-id` before admission, as Responses and Messages do (#6520):
         // the ChatGPT bridge forwards only canonical session headers, so the raw marker is lost.
         const sessionReq = withCallerSessionIdentity(req, admission);
-        return runAdmittedHttpTurn(sessionReq, policy, async turnAdmissionLease => withCors(
-          await handleChatCompletions(sessionReq, config, logCtx, { requestId, start, turnAdmissionLease, admission }),
-          req,
-          policy,
-        ), { requestId, start, logCtx });
+        // Only expose an id when the handler or a logged refusal owns its history row.
+        let ownsRequestLog = false;
+        const response = await runAdmittedHttpTurn(sessionReq, policy, async turnAdmissionLease => {
+          ownsRequestLog = true;
+          return withCors(
+            await handleChatCompletions(sessionReq, config, logCtx, { requestId, start, turnAdmissionLease, admission }),
+            req,
+            policy,
+          );
+        }, { requestId, start, logCtx, onLogged: () => { ownsRequestLog = true; } });
+        return ownsRequestLog ? withRequestLogId(response, requestId) : response;
       }
 
       if (url.pathname === "/v1/audio/transcriptions" && req.method === "POST") {

package/src/server/index/websocket-handler.ts

@@ -89,6 +89,7 @@ import {
 import type { ServeOptionsContext } from "./serve-options";
 import type { RequestMetricsRecorder } from "../request-metrics";
 import { resolveInboundBodyLimitBytes } from "../request-decompress";
+import { responseToolOwnership } from "../responses/response-tool-ownership";
 
 /**
  * The WebSocket half of the Bun.serve options, split out of serve-options.ts to keep that file
@@ -184,6 +185,8 @@ export function createWebsocketHandler(
           }
           return;
         }
+        if (ws.data.responsesActivity?.closing) return;
+        ws.data.responsesActivity?.touch();
         const rawBytes = typeof raw === "string" ? Buffer.byteLength(raw) : raw.byteLength;
         if (rawBytes > MAX_WS_FRAME_BYTES) {
           sendJsonFrame(ws, buildWsErrorFrame(413, {
@@ -223,6 +226,7 @@ export function createWebsocketHandler(
             if (frame.type === "response.inject") {
               if (!ws.data.nativeControl?.inject) throw new NativeSteeringError("injection_not_supported", "Native injection is disabled or unavailable on this route.");
               ws.data.nativeControl.inject(frame);
+              ws.data.responsesActivity?.acceptResults(frame.input);
               return;
             }
             if (frame.type === "response.steer") {
@@ -230,7 +234,10 @@ export function createWebsocketHandler(
               ws.data.nativeControl.steer(frame);
               return;
             }
-            if (ws.data.nativeControl?.continue(frame)) return;
+            if (ws.data.nativeControl?.continue(frame)) {
+              ws.data.responsesActivity?.acceptResults(frame.input);
+              return;
+            }
           } catch (error) {
             sendJsonFrame(ws, buildWsErrorFrame(400, {
               type: "invalid_request_error",
@@ -294,6 +301,7 @@ export function createWebsocketHandler(
         }
 
         // Only a genuinely admitted turn may receive steering or continuations.
+        const finishActivity = ws.data.responsesActivity?.beginTurn(frame.input);
         ws.data.nativeControl = nativeControl;
         const payload: Record<string, unknown> = { ...frame };
         delete payload.type;
@@ -346,11 +354,16 @@ export function createWebsocketHandler(
                 terminalRecorder = recorder;
               },
             });
+            const observeLog = nativeControl?.relayActive
+              ? createNativeSteeringLogObserver(logCtx, () => recordFirstOutput(logCtx, start))
+              : (payload: string) => inspectResponseLogSsePayload(logCtx, payload);
+            const providerExecuted = responseToolOwnership(response);
             await sendResponseToWebSocket(ws, response, isCurrent, {
               untilEof: nativeControl?.relayActive === true,
-              onSsePayload: nativeControl?.relayActive
-                ? createNativeSteeringLogObserver(logCtx, () => recordFirstOutput(logCtx, start))
-                : payload => inspectResponseLogSsePayload(logCtx, payload),
+              onSsePayload: payload => {
+                ws.data.responsesActivity?.observePayload(payload, providerExecuted);
+                observeLog(payload);
+              },
               onTerminal: status => {
                 terminalRecorder?.(status, logCtx.terminalHttpStatus);
                 finalizeLog(httpStatusForRequestLogTerminal(status, logCtx), {
@@ -392,6 +405,7 @@ export function createWebsocketHandler(
               /* socket already gone or send dropped */
             }
           } finally {
+            finishActivity?.();
             turnAdmissionLease.release();
             if (ws.data.nativeControl === nativeControl) ws.data.nativeControl = undefined;
             if (!logged && turnAbort.signal.aborted) finalizeLog(499);