@bitkyc08/opencodex 2.87.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,
@@ -44,6 +44,7 @@ import {
   type TranslatorBudget,
 } from "../lib/translator-budget";
 import { buildNonOpenAIToolCatalogNudgeForTools } from "./tool-catalog-nudge";
+import { geminiProgressLead, trimsGeminiProgressHistory } from "./google-progress-history";
 import { configuredReasoningEfforts, mapReasoningEffort } from "../reasoning-effort";
 
 // Google-family models (Gemini/Vertex/Antigravity) tend to emit long running commentary between
@@ -332,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 {
@@ -369,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.
@@ -466,11 +475,26 @@ function messagesToGeminiFormat(
         const aMsg = msg as OcxAssistantMessage;
         const parts: unknown[] = [];
         const toolCalls: Array<{ wireCallId: string; wireName: string }> = [];
+        // Progress text before a Gemini tool call replays as its lead sentence, so planning the
+        // model leaked into visible text is not copied forward (google-progress-history.ts).
+        const trimProgress = trimsGeminiProgressHistory(identityModelId)
+          && aMsg.phase !== "final_answer"
+          && aMsg.content.some(part => part.type === "toolCall");
+        let progressLeadKept = false;
+        let afterToolCall = false;
         for (const p of aMsg.content) {
           if (p.type === "text") {
-            const textPart = geminiTextPart((p as OcxTextContent).text);
+            let text: unknown = (p as OcxTextContent).text;
+            if (trimProgress && !afterToolCall) {
+              if (progressLeadKept || typeof text !== "string") continue;
+              text = geminiProgressLead(text);
+              if (text === undefined) continue;
+              progressLeadKept = true;
+            }
+            const textPart = geminiTextPart(text);
             if (textPart) parts.push(textPart);
           } else if (p.type === "toolCall") {
+            afterToolCall = true;
             const tc = p as OcxToolCall;
             // Preserve the thought signature on the function-call part so Antigravity/Gemini-3
             // reasoning continuity survives history-driven (stateless) turns, not just same-process
@@ -535,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;
@@ -1010,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;
@@ -1176,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
@@ -1194,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) };
       }
 
@@ -1238,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

@@ -1,5 +1,6 @@
 import type {
   AdapterEvent,
+  AnthropicServerBlocks,
   OcxMessagePhase,
   OcxProviderContinuationState,
   OcxProviderOpaqueToolCallMetadata,
@@ -22,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;
@@ -63,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>
@@ -91,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 };
@@ -186,9 +197,12 @@ export function adapterFailureFromEvent(event: Extract<AdapterEvent, { type: "er
  * This fixes items created from here on. History recorded before it is repaired at the
  * replay boundary by `backfillWebSearchQueries()` in the Responses adapter.
  */
-export function webSearchAction(queries: string[], fetch?: { url: string }): Record<string, unknown> {
+export function webSearchAction(queries: string[], anthropic?: AnthropicServerBlocks): Record<string, unknown> {
   // Anthropic's server-side web_fetch opens one page instead of searching.
-  if (fetch) return { type: "open_page", url: fetch.url };
+  if (anthropic?.use.name === "web_fetch") {
+    const url = (anthropic.result.content as { url?: unknown } | undefined)?.url ?? (anthropic.use.input as { url?: unknown }).url;
+    return { type: "open_page", url: typeof url === "string" ? url : "" };
+  }
   const first = queries[0] ?? "";
   return { type: "search", query: first, queries: queries.length > 0 ? queries : [first] };
 }

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,10 +546,10 @@ function buildResponseJSONWithBudget(
         flushToolCall();
         const safeSources = safeWebSearchSources(e.sources);
         pushOutput({
-          type: "web_search_call", id: `ws_${uuid()}`, status: e.status ?? "completed",
-          action: webSearchAction(e.queries, e.fetch),
+          type: "web_search_call", id: webSearchCellItemId(e.itemId), status: e.status ?? "completed",
+          action: webSearchAction(e.queries, e.anthropic),
           ...(safeSources.length > 0 ? { sources: safeSources } : {}),
-          ...(e.fetch ? { fetch_result: e.fetch.result } : {}),
+          ...(e.anthropic ? { anthropic_blocks: e.anthropic } : {}),
         });
         if (safeSources.length > 0) {
           for (const source of safeSources) {

package/src/bridge/sse.ts

@@ -1,6 +1,7 @@
 import { anthropicProgressItems } from "../responses/anthropic-progress";
 import type {
   AdapterEvent,
+  AnthropicServerBlocks,
   OcxMessagePhase,
   OcxProviderContinuationState,
   OcxProviderOpaqueToolCallMetadata,
@@ -49,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";
 
@@ -685,15 +686,15 @@ export function bridgeToResponsesSSE(
       // leaves a "Searching the web" spinner spinning forever.
       // `sources` rides on the done item (additive field; codex-rs serde ignores unknown fields) so
       // downstream translators (claude outbound) can fill web_search_tool_result content.
-      // `fetch` (Anthropic's server-side web_fetch) makes the cell a page open and rides its result
-      // verbatim as `fetch_result`, for the same claude outbound translator.
-      const closeCurrentWebSearch = (status: "completed" | "failed", queries: string[], sources?: { url: string; title?: string }[], fetch?: { url: string; result: unknown }) => {
+      // `anthropic` (Anthropic's server-side call) rides verbatim as `anthropic_blocks`, for the same
+      // claude outbound translator; a web_fetch makes the cell a page open.
+      const closeCurrentWebSearch = (status: "completed" | "failed", queries: string[], sources?: { url: string; title?: string }[], anthropic?: AnthropicServerBlocks) => {
         if (!currentWebSearch) return;
         const item = {
           type: "web_search_call", id: currentWebSearch.itemId, status,
-          action: webSearchAction(queries, fetch),
+          action: webSearchAction(queries, anthropic),
           ...(sources && sources.length > 0 ? { sources } : {}),
-          ...(fetch ? { fetch_result: fetch.result } : {}),
+          ...(anthropic ? { anthropic_blocks: anthropic } : {}),
         };
         emit("response.output_item.done", { output_index: currentWebSearch.outputIndex, item });
         retainFinishedItem(item as OutputItem);
@@ -769,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();
@@ -787,6 +793,7 @@ export function bridgeToResponsesSSE(
           sequence_number: seq++,
           response: {
             ...responseSnapshot("failed", finishedItems),
+            ...(usage ? { usage: responsesUsage(usage) } : {}),
             error: failure,
             last_error: failure,
           },
@@ -1210,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" },
@@ -1223,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" },
@@ -1231,7 +1238,7 @@ export function bridgeToResponsesSSE(
                 currentWebSearch = { itemId: wsItemId2, eventId: event.id, outputIndex };
               }
               const safeSources = safeWebSearchSources(event.sources);
-              closeCurrentWebSearch(event.status ?? "completed", event.queries, safeSources, event.fetch);
+              closeCurrentWebSearch(event.status ?? "completed", event.queries, safeSources, event.anthropic);
               // Queue this search's sources for the next assistant message (dedup by URL).
               if (safeSources.length > 0) {
                 for (const source of safeSources) {

package/src/claude/inbound-content-options.ts

@@ -87,6 +87,72 @@ export function declaredAnthropicServerTools(raw: unknown): Rec[] | undefined {
   return tools.length > 0 ? tools : undefined;
 }
 
+/** Validate original call/result order without inventing inputs or pairing a later call backwards. */
+function replayableServerRun(run: readonly Rec[]): boolean {
+  const pending = new Map<string, Rec>();
+  const completed = new Set<string>();
+  for (const block of run) {
+    if (block.type === "server_tool_use") {
+      const { id, name, input } = block;
+      if (typeof id !== "string" || !id.startsWith("srvtoolu_") || pending.has(id) || completed.has(id)
+        || (name !== "web_search" && name !== "web_fetch") || !isRec(input)) return false;
+      const prototype = Object.getPrototypeOf(input);
+      const required = input[name === "web_search" ? "query" : "url"];
+      if ((prototype !== Object.prototype && prototype !== null)
+        || typeof required !== "string" || required.trim().length === 0) return false;
+      pending.set(id, block);
+    } else {
+      const id = block.tool_use_id;
+      if (typeof id !== "string") return false;
+      const call = pending.get(id);
+      if (!call || block.type !== `${call.name}_tool_result`
+        || (Array.isArray(block.content) && !block.content.every(h => isRec(h) && typeof h.encrypted_content === "string"))) return false;
+      pending.delete(id);
+      completed.add(id);
+    }
+  }
+  return completed.size > 0 && pending.size === 0;
+}
+
+/**
+ * Completed Anthropic server-tool exchanges (`server_tool_use` + `web_search_tool_result` /
+ * `web_fetch_tool_result`) in the caller's assistant history. The Responses body drops them, so
+ * an Anthropic destination re-inserts them out of body, keyed by the block that follows each run
+ * in its message: `call:<tool_use id>`, `text:<text>`, `thinking:<signature>` or
+ * `redacted:<data>`, all of which survive translation. An anchor that occurs more than once in the
+ * assistant history (string content included) cannot name one owner, so its run stays dropped,
+ * as it was before replay existed. A run with none, an unpaired call, a
+ * non-Anthropic id, or a search hit without `encrypted_content` is not replayable and stays dropped.
+ */
+export function replayedAnthropicServerBlocks(raw: unknown): Map<string, Rec[]> | undefined {
+  if (!isRec(raw) || !Array.isArray(raw.messages)) return undefined;
+  const out = new Map<string, Rec[]>();
+  const seen = new Map<string, number>();
+  const count = (anchor: string) => seen.set(anchor, (seen.get(anchor) ?? 0) + 1);
+  for (const message of raw.messages) {
+    if (!isRec(message) || message.role !== "assistant") continue;
+    if (typeof message.content === "string") count(`text:${message.content}`);
+    if (!Array.isArray(message.content)) continue;
+    let run: Rec[] = [];
+    for (const block of message.content.filter(isRec)) {
+      if (block.type === "server_tool_use" || block.type === "web_search_tool_result" || block.type === "web_fetch_tool_result") {
+        // The caller's breakpoints are dropped on this lane, as for the declared tools above.
+        run.push({ ...block, cache_control: undefined });
+        continue;
+      }
+      const anchor = block.type === "tool_use" ? `call:${String(block.id)}`
+        : block.type === "text" ? `text:${String(block.text)}`
+        : block.type === "thinking" ? `thinking:${String(block.signature)}`
+        : block.type === "redacted_thinking" ? `redacted:${String(block.data)}` : undefined;
+      if (anchor) count(anchor);
+      if (anchor && replayableServerRun(run)) out.set(anchor, run);
+      run = [];
+    }
+  }
+  for (const anchor of out.keys()) if ((seen.get(anchor) ?? 0) > 1) out.delete(anchor);
+  return out.size > 0 ? out : undefined;
+}
+
 export function toolChoiceToResponses(choice: unknown, body: Rec): void {
   if (!isRec(choice)) return;
   if (choice.disable_parallel_tool_use === true) body.parallel_tool_calls = false;