@bitkyc08/opencodex 2.88.0 → 2.89.0

package/src/adapters/google.ts

@@ -36,7 +36,7 @@ import {
   observeAntigravityReplay,
 } from "./google-antigravity-replay";
 import { canonicalAntigravityUsageModel, resolveAntigravityEffortWireModel } from "../providers/antigravity-models";
-import { googleVertexLocationConfigError } from "../providers/google-vertex-location";
+import { selectVertexEndpoint, vertexInferenceUrl, vertexReplayModelKey } from "./google-vertex-endpoint";
 import { forgetThoughtSignatureForReplay, lookupReplayThoughtSignature } from "../responses/thought-signature-replay";
 import {
   isTranslatorBudgetExceededError,
@@ -333,13 +333,20 @@ function geminiToolResultParts(
   msg: OcxToolResultMessage,
   wireName: string,
   wireCallId: string,
+  nestToolResultImages: boolean,
 ): unknown[] {
   const functionResponse: Record<string, unknown> = {
     name: wireName,
     response: { result: geminiToolResultText(msg.content) },
     id: wireCallId,
   };
-  return [{ functionResponse }, ...toolResultImageParts(msg.content)];
+  const images = toolResultImageParts(msg.content);
+  // Vertex Argon rejects image siblings beside a functionResponse as an unsupported model tail.
+  if (nestToolResultImages && images.length > 0) {
+    functionResponse.parts = images;
+    return [{ functionResponse }];
+  }
+  return [{ functionResponse }, ...images];
 }
 
 function geminiMissingToolResultPart(wireName: string, wireCallId: string): unknown {
@@ -370,6 +377,7 @@ function messagesToGeminiFormat(
   identityModelId: string,
   stripRejectedClaudeSdkParagraph = false,
   isCloudCodeAssist = false,
+  nestToolResultImages = false,
 ): { systemInstruction?: unknown; contents: unknown[]; replayedCallIds: string[] } {
   // Neutralize Codex's GPT-5 identity line (Gemini/Antigravity share this path) so a routed model
   // never misreports as GPT-5/OpenAI, and never leaks the proxy identity upstream.
@@ -551,13 +559,17 @@ function messagesToGeminiFormat(
           const responseParts: unknown[] = [];
           for (const call of toolCalls) {
             const result = resultsById.get(call.wireCallId);
-            if (result) responseParts.push(...geminiToolResultParts(result, call.wireName, call.wireCallId));
+            if (result) responseParts.push(...geminiToolResultParts(result, call.wireName, call.wireCallId, nestToolResultImages));
             else responseParts.push(geminiMissingToolResultPart(call.wireName, call.wireCallId));
           }
-          for (const orphan of orphanResults) {
-            responseParts.push(...geminiOrphanToolResultParts(orphan));
-          }
+          const orphanParts = orphanResults.flatMap(geminiOrphanToolResultParts);
           contents.push({ role: "user", parts: responseParts });
+          // Orphan images cannot share Argon's response batch or claim another call's ownership.
+          if (nestToolResultImages && orphanParts.some(part => typeof part === "object" && part !== null && "inline_data" in part)) {
+            contents.push({ role: "user", parts: orphanParts });
+          } else {
+            responseParts.push(...orphanParts);
+          }
           i = j - 1;
         }
         break;
@@ -1026,6 +1038,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         identityModelId,
         stripRejectedClaudeSdkParagraph,
         isCloudCodeAssist,
+        provider.googleMode === "vertex" && parsed.modelId === "gemini-4-argon",
       );
       lastInjectedCallIds = [...replayedCallIds];
       lastReasoningReplayScope = parsed._reasoningReplayScope;
@@ -1192,9 +1205,10 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         const compiled = compileGoogleWireBody(body, toolSchemaProfile, toolSchemaPolicy);
         reportToolSchemaLoss(compiled.toolSchemaLossReport);
         restoreGoogleToolName = compiled.restoreToolName;
-        const vertexProject = provider.project || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT || "api-key";
-        const vertexLocation = provider.location || process.env.GOOGLE_CLOUD_LOCATION || "global";
-        vertexReplayModel = `vertex:${vertexProject}:${vertexLocation}:${parsed.modelId}`;
+        const apiKey = resolveVertexApiKey(provider.apiKey);
+        const vertexEndpoint = selectVertexEndpoint(provider, Boolean(apiKey));
+        const url = vertexInferenceUrl(vertexEndpoint, parsed.modelId, method, streamParam);
+        vertexReplayModel = vertexReplayModelKey(vertexEndpoint, parsed.modelId);
         vertexReplaySession = vertexReplaySessionId(parsed);
         // Compile names before replay so the cache matches the exact provider-visible
         // functionCall identity. This is the same bounded TTL/LRU store used by CCA, with the
@@ -1210,27 +1224,13 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
             (compiled.body as { contents: unknown[] }).contents,
           );
         }
-        // Vertex AI: project/location endpoint with GCP ADC, or x-goog-api-key fast path.
-        const apiKey = resolveVertexApiKey(provider.apiKey);
-        if (apiKey) {
-          const url = `https://aiplatform.googleapis.com/v1/publishers/google/models/${parsed.modelId}:${method}${streamParam}`;
-          headers["x-goog-api-key"] = apiKey;
-          return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
+        // Endpoint, location and model path were validated above, before any credential is attached.
+        if (apiKey) headers["x-goog-api-key"] = apiKey;
+        else {
+          // Resolve each marker per request; never share a process-global active account.
+          const markerAccount = gcpCredentialMarkerAccount(provider.apiKey);
+          headers["Authorization"] = `Bearer ${await getVertexAccessToken({ markerAccount })}`;
         }
-        const project = provider.project || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT;
-        if (!project) throw new Error("Vertex AI requires a project id (provider.project or GOOGLE_CLOUD_PROJECT/GCLOUD_PROJECT).");
-        const location = provider.location || process.env.GOOGLE_CLOUD_LOCATION;
-        if (!location) throw new Error("Vertex AI requires a location (provider.location or GOOGLE_CLOUD_LOCATION).");
-        const locationError = googleVertexLocationConfigError(location);
-        if (locationError) throw new Error(locationError);
-        const host = location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`;
-        const url = `https://${host}/v1/projects/${project}/locations/${location}/publishers/google/models/${parsed.modelId}:${method}${streamParam}`;
-        // The marker account travels per-request as an argument (never process-global state): a
-        // module-level "active marker" written at routing time would race across concurrent
-        // requests for different providers and could resolve one call with another's credential.
-        const markerAccount = gcpCredentialMarkerAccount(provider.apiKey);
-        const token = await getVertexAccessToken({ markerAccount });
-        headers["Authorization"] = `Bearer ${token}`;
         return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
       }
 
@@ -1254,6 +1254,12 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       const compiled = compileGoogleWireBody(body, toolSchemaProfile, toolSchemaPolicy);
       reportToolSchemaLoss(compiled.toolSchemaLossReport);
       restoreGoogleToolName = compiled.restoreToolName;
+      // A functionCall issued by another model (a combo hop, #7298) has no Gemini signature, and
+      // Gemini 3 refuses the turn without one. The same Gemini-only sentinel CCA and Vertex
+      // apply; a real signature carried by history always wins.
+      if (Array.isArray((compiled.body as { contents?: unknown[] }).contents)) {
+        applyAntigravityThoughtSignatureFallback(routedModelId, (compiled.body as { contents: unknown[] }).contents);
+      }
       return { url, method: "POST", headers, body: JSON.stringify(compiled.body) };
     },
 

package/src/adapters/openai-responses/compaction-search-history.ts

@@ -114,3 +114,30 @@ export function renderCompactionSearchHistoryItems(items: readonly unknown[], re
   if (omissionIndex >= 0) out[omissionIndex] = omissionNote(omitted);
   return out;
 }
+
+function isHostedSearchTool(tool: unknown): boolean {
+  return isPlainObject(tool) && typeof tool.type === "string" && tool.type.startsWith("web_search");
+}
+
+/**
+ * True when the outbound body declares a hosted search tool, either top-level or inside a Lite
+ * `additional_tools` input wrapper. Read on the final body, after unsupported hosted tools were
+ * stripped, so a declaration the destination never sees does not count.
+ */
+export function declaresHostedWebSearch(body: Record<string, unknown>): boolean {
+  if (Array.isArray(body.tools) && body.tools.some(isHostedSearchTool)) return true;
+  return Array.isArray(body.input) && body.input.some(item => isPlainObject(item)
+    && item.type === "additional_tools" && Array.isArray(item.tools) && item.tools.some(isHostedSearchTool));
+}
+
+/**
+ * Project unreferenced hosted `web_search_call` history into reference notes. A same-input
+ * `item_reference` to a hosted cell keeps that cell structural. Returns the original body when
+ * there is nothing to project.
+ */
+export function projectHostedSearchHistory(body: Record<string, unknown>): Record<string, unknown> {
+  if (!Array.isArray(body.input) || !body.input.some(item => isPlainObject(item) && item.type === "web_search_call")) return body;
+  const referencedIds = new Set(body.input.flatMap(item => isPlainObject(item)
+    && item.type === "item_reference" && typeof item.id === "string" ? [item.id] : []));
+  return { ...body, input: renderCompactionSearchHistoryItems(body.input, referencedIds) };
+}

package/src/adapters/openai-responses/passthrough.ts

@@ -53,7 +53,7 @@ import { stripMuseSparkUnsupportedWebSearchFields, stripOpenAiOnlyWebSearchField
 import { observeOutbound } from "../../usage/cache-diagnostic";
 
 import { normalizeMuseToolChoice } from "./muse-tool-choice";
-import { renderCompactionSearchHistoryItems } from "./compaction-search-history";
+import { declaresHostedWebSearch, projectHostedSearchHistory, renderCompactionSearchHistoryItems } from "./compaction-search-history";
 import { stripKimiEmptyAssistantMessages } from "./empty-assistant";
 
 /**
@@ -135,7 +135,8 @@ function usageFromResponsesPayload(payload: unknown): OcxUsage | undefined {
   const knownKeys = new Set(["input_tokens", "output_tokens", "total_tokens", "input_tokens_details", "output_tokens_details"]);
   const hasExtras = Object.keys(usage).some(key => !knownKeys.has(key))
     || (isPlainObject(usage.input_tokens_details)
-      && Object.keys(usage.input_tokens_details).some(key => key !== "cached_tokens" && key !== "cache_write_tokens"))
+      && Object.keys(usage.input_tokens_details).some(key => key !== "cached_tokens" && key !== "cache_write_tokens"
+        && key !== "cache_write_1h_tokens"))
     || (isPlainObject(usage.output_tokens_details)
       && Object.keys(usage.output_tokens_details).some(key => key !== "reasoning_tokens"));
   if (inputTokens === 0 && outputTokens === 0 && !hasExtras) return undefined;
@@ -147,6 +148,8 @@ function usageFromResponsesPayload(payload: unknown): OcxUsage | undefined {
     ...(typeof usage.total_tokens === "number" ? { totalTokens: usage.total_tokens } : {}),
     ...(typeof inputDetails?.cached_tokens === "number" ? { cachedInputTokens: inputDetails.cached_tokens } : {}),
     ...(typeof inputDetails?.cache_write_tokens === "number" ? { cacheCreationInputTokens: inputDetails.cache_write_tokens } : {}),
+    ...(typeof inputDetails?.cache_write_1h_tokens === "number"
+      ? { cacheCreation1hInputTokens: inputDetails.cache_write_1h_tokens } : {}),
     ...(typeof outputDetails?.reasoning_tokens === "number" ? { reasoningOutputTokens: outputDetails.reasoning_tokens } : {}),
     ...(hasExtras ? { rawUsage: { ...usage } } : {}),
   };
@@ -492,16 +495,18 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
       // here, on the serialized body, not on the parsed selector. One place covers both the
       // HTTP and the WebSocket outbound, because the WS path transports this same request
       // instead of rebuilding it.
-      // Opt-in Codex Lite history policy: replay remaining hosted actions as untrusted metadata,
-      // after bridge restoration/tool validation. Tool declarations and other input stay intact.
-      if (provider.projectResponsesLiteHostedSearchHistory === true && url === `${CODEX_FORWARD_BASE_URL}/responses`
-        && !parsed._compactionRequest && !parsed._portableCompaction
-        && codexResponsesLiteSelected(headers, finalBody)
-        && isPlainObject(finalBody) && Array.isArray(finalBody.input)
-        && finalBody.input.some(item => isPlainObject(item) && item.type === "web_search_call")) {
-        const referencedIds = new Set(finalBody.input.flatMap(item => isPlainObject(item)
-          && item.type === "item_reference" && typeof item.id === "string" ? [item.id] : []));
-        finalBody = { ...finalBody, input: renderCompactionSearchHistoryItems(finalBody.input, referencedIds) };
+      // Hosted-search history projection, after bridge restoration and tool validation. Two
+      // triggers share one bounded renderer, and tool declarations and other input stay intact:
+      // 1. The opt-in Codex Lite policy covers ordinary turns and native v2 compaction triggers
+      //    (#7268). Portable compaction was already projected by the summary builder above.
+      // 2. Any request whose final tool surface declares no hosted search. Native Sol answers a
+      //    replayed web_search_call without a matching declaration with a generic server_error
+      //    (#7250), so the cells become untrusted reference notes instead of a doomed request.
+      if (isPlainObject(finalBody)
+        && ((provider.projectResponsesLiteHostedSearchHistory === true && url === `${CODEX_FORWARD_BASE_URL}/responses`
+          && !parsed._portableCompaction && codexResponsesLiteSelected(headers, finalBody))
+          || !declaresHostedWebSearch(finalBody))) {
+        finalBody = projectHostedSearchHistory(finalBody);
       }
       observeOutbound(parsed._rawBody, finalBody, headers);
       if (!isCanonicalOpenAiForwardProvider(provider)) {

package/src/adapters/openai-responses/reasoning.ts

@@ -163,7 +163,74 @@ export function sanitizeReasoningInputContent(
   });
 
   if (blankedPlaintext) opts?.onPlaintextReasoningBlanked?.();
-  return changed ? { ...raw, input } : body;
+  // Runs after the per-item pass so an item it emptied has already been backfilled, and a
+  // placeholder is only invented for a turn that carries no reasoning item at all.
+  const withTurnReasoning = opts?.requirePlaintextReasoning === true
+    ? backfillBareToolCallTurnReasoning(input)
+    : input;
+  if (withTurnReasoning !== input) changed = true;
+  return changed ? { ...raw, input: withTurnReasoning } : body;
+}
+
+/** Assistant-authored history items: what DeepSeek merges into one assistant message. */
+function isAssistantTurnItem(item: unknown): boolean {
+  if (!isPlainObject(item) || typeof item.type !== "string") return false;
+  if (item.type === "reasoning") return true;
+  if (item.type === "message") return item.role === "assistant";
+  return item.type.endsWith("_call");
+}
+
+function isClientToolCallItem(item: unknown): boolean {
+  return isPlainObject(item)
+    && (item.type === "function_call" || item.type === "custom_tool_call" || item.type === "local_shell_call");
+}
+
+/**
+ * Give every assistant tool-call turn that has NO reasoning item a minimal plaintext one (#7298).
+ *
+ * A Combo can serve the turn that issued a tool call on one model and the continuation on
+ * another. When the issuing model was a GPT turn that produced no reasoning item (or the item
+ * was dropped upstream), the strict destination sees a bare `function_call` and DeepSeek's
+ * thinking mode refuses the whole request with `The reasoning_text in the thinking mode must be
+ * passed back to the API`. The per-item backfill above cannot help, because there is no item to
+ * backfill. This is the Responses-wire twin of the Chat adapter's `reasoning_content: " "`
+ * placeholder (#5421): the same single-space text, never fabricated reasoning, inserted at the
+ * head of the turn so it precedes the call exactly where a native turn's reasoning would be.
+ *
+ * A turn is a maximal run of assistant-authored items; any user message or tool output ends it.
+ * Turns that already carry a reasoning item, and turns with no client tool call, are untouched.
+ */
+export function backfillBareToolCallTurnReasoning(input: unknown[]): unknown[] {
+  const bareTurnStarts = new Set<number>();
+  let turnStart = -1;
+  let turnHasReasoning = false;
+  let turnHasToolCall = false;
+  const closeTurn = (): void => {
+    if (turnStart >= 0 && turnHasToolCall && !turnHasReasoning) bareTurnStarts.add(turnStart);
+    turnStart = -1;
+    turnHasReasoning = false;
+    turnHasToolCall = false;
+  };
+  for (let index = 0; index < input.length; index++) {
+    const item = input[index];
+    if (!isAssistantTurnItem(item)) {
+      closeTurn();
+      continue;
+    }
+    if (turnStart < 0) turnStart = index;
+    if ((item as Record<string, unknown>).type === "reasoning") turnHasReasoning = true;
+    if (isClientToolCallItem(item)) turnHasToolCall = true;
+  }
+  closeTurn();
+  if (bareTurnStarts.size === 0) return input;
+  const result: unknown[] = [];
+  for (let index = 0; index < input.length; index++) {
+    if (bareTurnStarts.has(index)) {
+      result.push({ type: "reasoning", summary: [], content: [{ type: "reasoning_text", text: " " }] });
+    }
+    result.push(input[index]);
+  }
+  return result;
 }
 
 /**

package/src/adapters/registry.ts

@@ -138,7 +138,7 @@ export const ADAPTER_REGISTRY = {
   zed: {
     wire: "zed",
     mutation: "codex-owned",
-    create: (provider: OcxProviderConfig, _context: AdapterFactoryContext) => createZedAdapter(provider),
+    create: (provider: OcxProviderConfig, context: AdapterFactoryContext) => createZedAdapter(provider, context.cacheRetention),
   },
   "mimo-free": {
     contractParent: "openai-chat",

package/src/adapters/upstream-http-error.ts

@@ -1,3 +1,4 @@
+import { inheritAccountAutoPauseResponse } from "../lib/account-auto-pause-response";
 import { readBoundedResponseBody } from "../lib/bounded-body";
 import { redactSecretString } from "../lib/redact";
 
@@ -40,9 +41,9 @@ export async function normalizeUpstreamHttpErrorResponse(
   const headers = new Headers(res.headers);
   headers.delete("content-encoding");
   headers.delete("content-length");
-  return new Response(await opts.formatMessage(payloadText), {
+  return inheritAccountAutoPauseResponse(res, new Response(await opts.formatMessage(payloadText), {
     status: res.status,
     statusText: res.statusText,
     headers,
-  });
+  }));
 }

package/src/adapters/zed.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import type { AdapterRequest, IncomingMeta, ProviderAdapter } from "./base";
 import { createAnthropicAdapter } from "./anthropic";
+import type { AnthropicCacheRetention } from "./anthropic/cache-retention";
 import { createGoogleAdapter } from "./google";
 import { createOpenAIChatAdapter } from "./openai-chat";
 import { createResponsesPassthroughAdapter } from "./openai-responses";
@@ -218,15 +219,17 @@ export function zedEventStream(
   return body.pipeThrough(output);
 }
 
-function createDelegate(provider: OcxProviderConfig, zedProvider: ZedProvider): ProviderAdapter {
+function createDelegate(provider: OcxProviderConfig, zedProvider: ZedProvider, cacheRetention?: AnthropicCacheRetention): ProviderAdapter {
   const config = delegateProvider(provider, zedProvider);
-  if (zedProvider === "anthropic") return createAnthropicAdapter(config);
+  // The delegate only borrows the api.anthropic.com body builder; the wire goes to Zed's
+  // gateway, which does not document the 1h TTL, so an omitted retention stays 5m here.
+  if (zedProvider === "anthropic") return createAnthropicAdapter(config, cacheRetention ?? "short");
   if (zedProvider === "google") return createGoogleAdapter(config);
   if (zedProvider === "open_ai") return createResponsesPassthroughAdapter(config);
   return createOpenAIChatAdapter(config);
 }
 
-export function createZedAdapter(provider: OcxProviderConfig): ProviderAdapter {
+export function createZedAdapter(provider: OcxProviderConfig, cacheRetention?: AnthropicCacheRetention): ProviderAdapter {
   let delegate: ZedDelegate | undefined;
   let credentials: ZedCredentials | undefined;
 
@@ -246,7 +249,7 @@ export function createZedAdapter(provider: OcxProviderConfig): ProviderAdapter {
       /* Model inference fallback below; a transient catalog outage must not block passthrough. */
     }
     const zedProvider = providerFromCatalog(catalog, parsed.modelId);
-    const selected = createDelegate(provider, zedProvider);
+    const selected = createDelegate(provider, zedProvider, cacheRetention);
     const safeIncoming: IncomingMeta = {
      headers: incoming?.headers ?? new Headers(),
      translatorBudget: incoming?.translatorBudget ?? createTranslatorBudget(),

package/src/bridge/internal.ts

@@ -23,6 +23,11 @@ export function uuid(): string {
   return crypto.randomUUID().replace(/-/g, "");
 }
 
+/** The client-visible id of a hosted search cell: the producer's `ws_` id when well-formed, else a fresh one. */
+export function webSearchCellItemId(candidate: string | undefined): string {
+  return typeof candidate === "string" && /^ws_[A-Za-z0-9_-]{1,128}$/.test(candidate) ? candidate : `ws_${uuid()}`;
+}
+
 /** Test-only: bound the abandoned-owned-budget watchdog delay (null restores). */
 export let ownedBudgetAbandonedMs = 10 * 60 * 1000;
 const OWNED_BUDGET_ABANDONED_DEFAULT_MS = ownedBudgetAbandonedMs;
@@ -64,7 +69,7 @@ export function responsesUsage(usage: OcxUsage | undefined): Record<string, unkn
   // normalized contract).
   const rawInputDetails = isRecord(raw.input_tokens_details)
     ? Object.fromEntries(Object.entries(raw.input_tokens_details as Record<string, unknown>)
-      .filter(([key]) => key !== "cache_write_tokens"))
+      .filter(([key]) => key !== "cache_write_tokens" && key !== "cache_write_1h_tokens"))
     : {} as Record<string, unknown>;
   const rawOutputDetails = isRecord(raw.output_tokens_details)
     ? raw.output_tokens_details as Record<string, unknown>
@@ -92,6 +97,11 @@ export function responsesUsage(usage: OcxUsage | undefined): Record<string, unkn
       usage.cacheCreationInputTokens,
       Math.max(0, inputTokens - cacheRead),
     );
+    // The 1-hour-TTL share of the write (Anthropic cache_creation split), only when reported,
+    // so a translated Messages client can price it at the 1h rate.
+    if (usage.cacheCreation1hInputTokens !== undefined) {
+      inputDetails.cache_write_1h_tokens = Math.min(usage.cacheCreation1hInputTokens, inputDetails.cache_write_tokens as number);
+    }
   }
   out.input_tokens_details = inputDetails;
   out.output_tokens_details = { ...rawOutputDetails, reasoning_tokens: usage.reasoningOutputTokens ?? 0 };

package/src/bridge/response-json.ts

@@ -42,7 +42,7 @@ import {
   type TranslatorBudget,
   type TranslatorBufferKind,
 } from "../lib/translator-budget";
-import { adapterFailureFromEvent, emptyChunks, joinChunks, responsesUsage, toolCallArgumentsUsable, uuid, webSearchAction } from "./internal";
+import { adapterFailureFromEvent, emptyChunks, joinChunks, responsesUsage, toolCallArgumentsUsable, uuid, webSearchAction, webSearchCellItemId } from "./internal";
 import type { OutputItem, StringChunks } from "./internal";
 import { bridgeToResponsesSSE } from "./sse";
 
@@ -546,7 +546,7 @@ function buildResponseJSONWithBudget(
         flushToolCall();
         const safeSources = safeWebSearchSources(e.sources);
         pushOutput({
-          type: "web_search_call", id: `ws_${uuid()}`, status: e.status ?? "completed",
+          type: "web_search_call", id: webSearchCellItemId(e.itemId), status: e.status ?? "completed",
           action: webSearchAction(e.queries, e.anthropic),
           ...(safeSources.length > 0 ? { sources: safeSources } : {}),
           ...(e.anthropic ? { anthropic_blocks: e.anthropic } : {}),

package/src/bridge/sse.ts

@@ -50,7 +50,7 @@ import {
   type TranslatorBudget,
   type TranslatorBufferKind,
 } from "../lib/translator-budget";
-import { adapterFailureFromEvent, emptyChunks, joinChunks, ownedBudgetAbandonedMs, responsesUsage, toolCallArgumentsCouldBeJson, toolCallArgumentsUsable, uuid, webSearchAction } from "./internal";
+import { adapterFailureFromEvent, emptyChunks, joinChunks, ownedBudgetAbandonedMs, responsesUsage, toolCallArgumentsCouldBeJson, toolCallArgumentsUsable, uuid, webSearchAction, webSearchCellItemId } from "./internal";
 import type { OutputItem, StringChunks } from "./internal";
 import { terminalRefusalFailure } from "./terminal-refusal";
 
@@ -770,9 +770,14 @@ export function bridgeToResponsesSSE(
         returnIterator();
       };
       let handlingTranslatorOverflow = false;
-      terminateForTranslatorOverflow = _error => {
+      terminateForTranslatorOverflow = error => {
         if (handlingTranslatorOverflow || terminated || clientCancelled || closed) return;
         handlingTranslatorOverflow = true;
+        // An adapter-raised overflow event carries the usage the turn already consumed; the
+        // provider billed it, so it must not be logged as zero.
+        const usage = (error as AdapterEvent | null | undefined)?.type === "error"
+          ? (error as Extract<AdapterEvent, { type: "error" }>).usage : undefined;
+        if (usage) options?.onUsage?.(usage);
         abortCurrentToolCallForTranslatorOverflow();
         currentWebSearch = null;
         releasePendingWebSources();
@@ -788,6 +793,7 @@ export function bridgeToResponsesSSE(
           sequence_number: seq++,
           response: {
             ...responseSnapshot("failed", finishedItems),
+            ...(usage ? { usage: responsesUsage(usage) } : {}),
             error: failure,
             last_error: failure,
           },
@@ -1211,7 +1217,7 @@ export function bridgeToResponsesSSE(
               flushHiddenRawReasoning();
               if (currentToolCall) closeCurrentToolCall();
               if (currentWebSearch) closeCurrentWebSearch("completed", []);
-              const wsItemId = `ws_${uuid()}`;
+              const wsItemId = webSearchCellItemId(event.itemId);
               emit("response.output_item.added", {
                 output_index: outputIndex,
                 item: { type: "web_search_call", id: wsItemId, status: "in_progress" },
@@ -1224,7 +1230,7 @@ export function bridgeToResponsesSSE(
               // (defensive), synthesize the added frame first so the done has a matching item.
               if (!currentWebSearch || currentWebSearch.eventId !== event.id) {
                 if (currentWebSearch) closeCurrentWebSearch("completed", []);
-                const wsItemId2 = `ws_${uuid()}`;
+                const wsItemId2 = webSearchCellItemId(event.itemId);
                 emit("response.output_item.added", {
                   output_index: outputIndex,
                   item: { type: "web_search_call", id: wsItemId2, status: "in_progress" },

package/src/claude/inbound.ts

@@ -21,6 +21,7 @@ import { stabilizeClaudeInstructionsForPromptCache } from "./inbound-cache-stabi
 import { decodeReasoningEnvelope, encodeReasoningEnvelope, OCX_REASONING_PREFIX } from "../responses/reasoning-envelope";
 import { inlineDocumentMarker } from "../responses/inline-document";
 import { createTranslatorBudget, type TranslatorBudget } from "../lib/translator-budget";
+import { collectAnthropicCacheTtls } from "../adapters/anthropic/cache-retention";
 
 
 
@@ -390,34 +391,19 @@ export type ClaudeCacheKeySource = "metadata" | "system" | null;
 /**
  * The translated lane places its own prompt-cache breakpoints, so the caller's are dropped;
  * their TTL is the one thing worth keeping. When every caller breakpoint asks for `ttl: "1h"`
- * (Claude Code on a subscription marks them so) this maps to `cacheRetention: "long"`. A mixed
- * caller (1h prefix, 5m tail) stays on the default: "long" also makes the moving per-turn
- * breakpoint 1h, which bills writes the caller asked to keep at the 5m rate at the 1h rate.
- * Read out of body: the Responses body has no field for it.
+ * (Claude Code on a subscription marks them so) this maps to `cacheRetention: "long"`. A caller
+ * that pins any breakpoint to an explicit non-1h TTL ("5m") maps to "short": "long" would also
+ * make the moving per-turn breakpoint 1h and bill writes the caller asked to keep at 5m at the
+ * 1h rate. Breakpoints without a TTL express no preference, so they fall through to the
+ * destination default (1h on first-party Anthropic). Read out of body: the Responses body has
+ * no field for it.
  */
-export function callerCacheRetention(raw: unknown): "long" | undefined {
-  if (!isRec(raw)) return undefined;
+export function callerCacheRetention(raw: unknown): "long" | "short" | undefined {
   // Top-level automatic caching is a breakpoint too, and content blocks nest (tool_result,
-  // search_result, document sources), so every block container is walked. Tool inputs and
-  // schemas are caller data, not blocks: a `cache_control` key there is not a breakpoint.
-  const ttls: unknown[] = [];
-  const visit = (node: unknown, depth: number): void => {
-    if (depth > 16) return;
-    if (Array.isArray(node)) { for (const item of node) visit(item, depth + 1); return; }
-    if (!isRec(node)) return;
-    if (isRec(node.cache_control)) ttls.push(node.cache_control.ttl);
-    for (const [key, value] of Object.entries(node)) {
-      if (key !== "cache_control" && key !== "input" && key !== "input_schema"
-        && (Array.isArray(value) || isRec(value))) visit(value, depth + 1);
-    }
-  };
-  if (isRec(raw.cache_control)) ttls.push(raw.cache_control.ttl);
-  visit(raw.system, 0);
-  visit(raw.tools, 0);
-  visit(raw.messages, 0);
-  return ttls.length > 0 && ttls.every(ttl => ttl === "1h")
-    ? "long"
-    : undefined;
+  // search_result, document sources), so every block container is walked.
+  const ttls = collectAnthropicCacheTtls(raw);
+  if (ttls.some(ttl => ttl !== undefined && ttl !== "1h")) return "short";
+  return ttls.length > 0 && ttls.every(ttl => ttl === "1h") ? "long" : undefined;
 }
 
 export interface ClaudeInboundTranslation {

package/src/claude/outbound.ts

@@ -156,6 +156,8 @@ export function anthropicUsage(usage: unknown, webSearchRequests = 0): Rec {
   const details = isRec(u.input_tokens_details) ? u.input_tokens_details : {};
   const cached = typeof details.cached_tokens === "number" ? details.cached_tokens : 0;
   const cacheWrite = typeof details.cache_write_tokens === "number" ? details.cache_write_tokens : 0;
+  const cacheWrite1h = typeof details.cache_write_1h_tokens === "number"
+    ? Math.max(0, Math.min(details.cache_write_1h_tokens, cacheWrite)) : undefined;
   const input = typeof u.input_tokens === "number" ? u.input_tokens : 0;
   const output = typeof u.output_tokens === "number" ? u.output_tokens : 0;
   return {
@@ -163,6 +165,9 @@ export function anthropicUsage(usage: unknown, webSearchRequests = 0): Rec {
     output_tokens: output,
     cache_read_input_tokens: cached,
     cache_creation_input_tokens: cacheWrite,
+    ...(cacheWrite1h !== undefined
+      ? { cache_creation: { ephemeral_5m_input_tokens: cacheWrite - cacheWrite1h, ephemeral_1h_input_tokens: cacheWrite1h } }
+      : {}),
     // Only successful searches are billed/counted (Anthropic contract; Claude Code cost accounting).
     ...(webSearchRequests > 0 ? { server_tool_use: { web_search_requests: webSearchRequests } } : {}),
   };

package/src/cli/account-api.ts

@@ -16,6 +16,7 @@ import { projectApiKeyQuotaRows } from "./account-key-quota";
 import { projectAccountHealth } from "./account-next-actions";
 import type { OAuthHealthLabel } from "../oauth/health";
 
+import { accountPauseDetailsSchema } from "../config/schema/account-auto-pause";
 export type AccountType = "codex" | "oauth" | "api-key";
 
 export interface AccountRow {
@@ -61,6 +62,7 @@ export interface AccountRow {
    * human listing (#2703).
    */
   paused?: boolean;
+  pauseDetails?: import("../types/account-auto-pause").AccountPauseDetails;
 }
 
 export type ClassifyResult = { type: AccountType } | { error: string };
@@ -342,6 +344,7 @@ interface CodexAccountDto {
   quota?: CodexQuotaDto | null;
   quotaRefresh?: unknown;
   paused?: boolean;
+  pauseDetails?: import("../types/account-auto-pause").AccountPauseDetails;
 }
 
 function projectQuota(quota: CodexQuotaDto | null | undefined): CodexQuotaDto | null {
@@ -415,6 +418,8 @@ export async function fetchCodexRows(
       ? a.autoSwitchThresholdOverride
       : null,
     paused: a.paused === true,
+    // Unknown display details are dropped defensively; the pause state above is retained.
+    pauseDetails: accountPauseDetailsSchema.safeParse(a.pauseDetails).data,
     ...(includeQuota ? {
       quota: projectQuota(a.quota),
       quotaRefresh: projectCodexQuotaRefreshOutcome(a.quotaRefresh),
@@ -432,6 +437,7 @@ interface OAuthAccountDto {
   healthLabel?: unknown;
   /** Present only for providers that support operator pause (generic OAuth pools). */
   paused?: boolean;
+  pauseDetails?: import("../types/account-auto-pause").AccountPauseDetails;
   autoSwitchThresholdOverride?: number | null;
   needsReauthReason?: "verify_account";
   autoSelectable?: boolean;
@@ -475,7 +481,8 @@ async function fetchOAuthRows(
     active: a.active ?? a.id === activeId,
     needsReauth: a.needsReauth,
     ...projectAccountHealth(a, name, a.id),
-    ...(a.paused === true ? { paused: true } : {}),
+    // Unknown display details are dropped defensively; paused remains authoritative.
+    ...(a.paused === true ? { paused: true, pauseDetails: accountPauseDetailsSchema.safeParse(a.pauseDetails).data } : {}),
     ...(isAnthropicOAuthInstance(name) && Object.hasOwn(a, "autoSwitchThresholdOverride") ? { autoSwitchThresholdOverride: a.autoSwitchThresholdOverride } : {}),
     ...(a.needsReauthReason === "verify_account" ? { needsReauthReason: a.needsReauthReason } : {}),
     ...(name === "kiro" && typeof a.autoSelectable === "boolean"
@@ -495,6 +502,8 @@ async function fetchOAuthRows(
 }
 
 interface ApiKeyDto {
+  disabled?: boolean;
+  pauseDetails?: import("../types/account-auto-pause").AccountPauseDetails;
   id: string;
   label?: string;
   masked?: string;
@@ -523,6 +532,9 @@ async function fetchKeyRows(deps: AccountDeps, baseUrl: string, name: string, qu
     label: k.label ?? k.masked,
     masked: k.masked,
     active: k.active ?? k.id === activeId,
+    paused: k.disabled === true,
+    // Unknown display details are dropped defensively; disabled still keeps the key paused.
+    pauseDetails: accountPauseDetailsSchema.safeParse(k.pauseDetails).data,
   }));
   return { rows, activeId, status: 200 };
 }