@bitkyc08/opencodex 2.87.0 → 2.89.0

package/src/adapters/anthropic.ts

@@ -1,3 +1,6 @@
+import { captureAnthropicRejectionPayloads, keepAnthropicReplayBlock } from "./anthropic-rejection-memo";
+import { anthropicDeclaredTools } from "./anthropic-tool-catalog";
+import { anthropicReplayContent, createAnthropicReplayCapture } from "./anthropic-replay";
 import { withAnthropicProgressUpdates } from "./anthropic-progress";
 import type { IncomingMeta, ProviderAdapter } from "./base";
 import { createAdapterTierMetadata, type AdapterTierMetadata } from "../providers/fastwire";
@@ -17,7 +20,7 @@ import type {
   OcxToolResultMessage,
   OcxUsage,
 } from "../types";
-import { isAllowedToolChoice, namespacedToolName, resolveToolChoiceWireName, toolChoiceToolPredicate } from "../types";
+import { isAllowedToolChoice, namespacedToolName, resolveToolChoiceWireName } from "../types";
 import { ANTHROPIC_OAUTH_BETA, CLAUDE_CODE_SYSTEM_INSTRUCTION, applyClaudeToolPrefix, stripClaudeToolPrefix } from "../oauth/anthropic";
 import { parseDataUrl } from "./image";
 import { enforceAnthropicImageLimits } from "./anthropic-image-guard";
@@ -32,6 +35,7 @@ import { decodeServerSentEvents } from "../lib/sse-decoder";
 import { isTranslatorBudgetExceededError, retainTranslatedEventBatch, type TranslatorBudget } from "../lib/translator-budget";
 import { isReasoningEffortOmitted, modelRecordValue } from "../reasoning-effort";
 import { applyAgentRouterLanguageFraming, isAgentRouterEndpoint } from "./agentrouter";
+import { anthropicCacheWrite1hTokens, resolveAnthropicCacheRetention, type AnthropicCacheRetention } from "./anthropic/cache-retention";
 import { claudeFamilyVersion, rejectsCombinedSampling, rejectsForcedToolChoice, rejectsSamplingParameters, supportsExplicitThinkingDisable, usesAdaptiveThinking, usesBetweenToolsFloor } from "./anthropic-model-contract";
 
 /** Map a user content part to an Anthropic content block (text or image source). */
@@ -73,8 +77,12 @@ const COMPAT_TOOL_PREFIX = "cx_";
 type CacheControl = { type: "ephemeral"; ttl?: "1h" | "5m" };
 const MAX_CACHE_BREAKPOINTS = 4;
 
-function resolveCacheControl(retention: "none" | "short" | "long" | undefined): CacheControl | undefined {
-  const r = retention ?? "short";
+/** Omitted retention follows the destination default (1h on first-party Anthropic, else 5m). */
+function resolveCacheControl(
+  retention: AnthropicCacheRetention | undefined,
+  provider: OcxProviderConfig,
+): CacheControl | undefined {
+  const r = resolveAnthropicCacheRetention(retention, provider);
   if (r === "none") return undefined;
   return r === "long" ? { type: "ephemeral", ttl: "1h" } : { type: "ephemeral" };
 }
@@ -283,7 +291,7 @@ function normalizeTtlOrdering(body: Record<string, unknown>): void {
   }
 }
 
-function isLikelyRealAnthropicThinkingSignature(signature: string | undefined): signature is string {
+export function isLikelyRealAnthropicThinkingSignature(signature: string | undefined): signature is string {
   if (typeof signature !== "string" || signature.length < 16) return false;
   if (/^(fc|call|msg|rs|resp|reasoning|item|ws|tool|func|function)[-_]/i.test(signature)) return false;
   return /^[A-Za-z0-9+/_=-]+$/.test(signature);
@@ -522,13 +530,13 @@ function streamedToolArgumentsParse(assembled: string): boolean {
   }
 }
 
-/** A string field of a server tool's streamed input (web_search `query`, web_fetch `url`); "" when it did not parse. */
-function serverToolInputField(json: string, key: "query" | "url"): string {
+/** A server tool's complete streamed input; undefined when it cannot be recovered. */
+function serverToolInput(json: string): Record<string, unknown> | undefined {
   try {
-    const value = (JSON.parse(json) as Record<string, unknown> | null)?.[key];
-    return typeof value === "string" ? value : "";
+    const input = JSON.parse(json) as unknown;
+    return isAnthropicRecord(input) ? input : undefined;
   } catch {
-    return "";
+    return undefined;
   }
 }
 
@@ -640,6 +648,7 @@ function usageFromAnthropic(usage: unknown): OcxUsage | undefined {
   // estimate from visible summaries. Invalid optional detail leaves totals intact.
   const thinking = isAnthropicRecord(usage.output_tokens_details) ? usage.output_tokens_details.thinking_tokens : undefined;
   const reasoningOutputTokens = typeof thinking === "number" && Number.isFinite(thinking) && thinking >= 0 && thinking <= output ? thinking : undefined;
+  const write1h = anthropicCacheWrite1hTokens(usage, write);
   return {
     inputTokens,
     outputTokens: output,
@@ -648,6 +657,7 @@ function usageFromAnthropic(usage: unknown): OcxUsage | undefined {
       cachedInputTokens: read,
       cacheReadInputTokens: read,
       cacheCreationInputTokens: write,
+      ...(write1h !== undefined ? { cacheCreation1hInputTokens: write1h } : {}),
     } : {}),
   };
 }
@@ -735,7 +745,16 @@ function orphanToolResultContent(msg: OcxToolResultMessage): string | unknown[]
 function messagesToAnthropicFormat(
   parsed: OcxParsedRequest,
   toolNames: { toWire: (name: string) => string },
+  serverReplay?: ReadonlyMap<string, readonly Record<string, unknown>[]>,
 ): { system: string | undefined; messages: unknown[] } {
+  // The client's server-tool exchanges go back ahead of the block they preceded. Their anchors are
+  // unique in the caller's history (replayedAnthropicServerBlocks drops repeated ones); each is used once.
+  const pendingReplay = new Map(serverReplay);
+  const replayed = (anchor: string) => {
+    const blocks = pendingReplay.get(anchor) ?? [];
+    pendingReplay.delete(anchor);
+    return blocks;
+  };
   // One allocator for the whole request: a tool_result must resolve to the SAME wire id its
   // call got, and two distinct raw ids must never collapse into one. Conforming ids are claimed
   // first so a rewritten id can never squat on an id another call legitimately owns.
@@ -750,8 +769,8 @@ function messagesToAnthropicFormat(
     }
   }
   const toolCatalogNudge = buildNonOpenAIToolCatalogNudgeForTools(
-    parsed.context.tools,
-    parsed.options.toolChoice,
+    anthropicDeclaredTools(parsed),
+    undefined,
     tool => toolNames.toWire(namespacedToolName(tool.namespace, tool.name)),
   );
   const systemParts = [...(parsed.context.systemPrompt ?? []), ...(toolCatalogNudge ? [toolCatalogNudge] : [])];
@@ -781,6 +800,7 @@ function messagesToAnthropicFormat(
       case "assistant": {
         const aMsg = msg as OcxAssistantMessage;
         const preface: unknown[] = [];
+
         const toolUses: unknown[] = [];
         const originalOrder: unknown[] = [];
         const appendPreface = (block: unknown) => { preface.push(block); originalOrder.push(block); };
@@ -789,9 +809,13 @@ function messagesToAnthropicFormat(
         for (const part of aMsg.content) {
           if (part.type === "text") {
             const text = (part as OcxTextContent).text;
+            for (const b of replayed(`text:${text}`)) appendPreface(b);
             if (text) appendPreface({ type: "text", text });
           } else if (part.type === "thinking") {
             const t = part as OcxThinkingContent;
+            // Server blocks that preceded this reasoning keep their place, even when it is dropped below.
+            for (const data of t.redacted ?? []) for (const b of replayed(`redacted:${data}`)) appendPreface(b);
+            for (const b of replayed(`thinking:${t.signature}`)) appendPreface(b);
             // History minted under another serving identity (or already rejected as opaque) is not
             // this destination's to verify: drop its opaque blocks, as the Responses passthrough does.
             if (parsed._stripReasoningEncryptedContent === true) continue;
@@ -806,6 +830,7 @@ function messagesToAnthropicFormat(
             }
           } else if (part.type === "toolCall") {
             const tc = part as OcxToolCall;
+            for (const b of replayed(`call:${tc.id}`)) appendPreface(b);
             const flatName = namespacedToolName(tc.namespace, tc.name);
             // Normalized here, and identically for the matching tool_result above, so a history
             // replayed from another provider path keeps its call/result pairing (#1767).
@@ -824,9 +849,15 @@ function messagesToAnthropicFormat(
         }
         // Anthropic treats text/thinking after tool_use as ending the tool turn, which makes
         // earlier tool_use ids look unpaired (#620 / common multi-step history shape).
-        // Signed native blocks bind the source ordering, including updates between tool calls.
-        // Keep the legacy repair only for unsigned/cross-provider history.
-        const content = signed ? originalOrder : [...preface, ...toolUses];
+        const captured = anthropicReplayContent(aMsg);
+        if (captured) {
+          const expected = toolUses as Array<{ id: string; name: string }>;
+          const actual = captured.filter(block => block.type === "tool_use");
+          if (actual.length !== expected.length || actual.some((block, index) => block.id !== expected[index]?.id || block.name !== expected[index]?.name)) {
+            throw new Error("Anthropic search replay tool identity changed");
+          }
+        }
+        const content = (captured ?? (signed ? originalOrder : [...preface, ...toolUses])).filter(block => keepAnthropicReplayBlock(parsed, block as Record<string, unknown>));
         if (content.length === 0) break;
         messages.push({ role: "assistant", content });
         if (toolUseIds.length > 0) {
@@ -889,9 +920,7 @@ function messagesToAnthropicFormat(
 
 function toolsToAnthropicFormat(parsed: OcxParsedRequest, toolNames: { toWire: (name: string) => string }): unknown[] | undefined {
   if (!parsed.context.tools || parsed.context.tools.length === 0) return undefined;
-  const tools = isAllowedToolChoice(parsed.options.toolChoice)
-    ? parsed.context.tools.filter(toolChoiceToolPredicate(parsed.options.toolChoice, parsed.context.tools))
-    : parsed.context.tools;
+  const tools = anthropicDeclaredTools(parsed);
   if (tools.length === 0) return undefined;
   const converted = tools.map(t => ({
     name: toolNames.toWire(namespacedToolName(t.namespace, t.name)),
@@ -998,7 +1027,9 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         throw new Error("anthropic provider requires a non-empty apiKey (authMode: key)");
       }
 
-      const { system, messages } = messagesToAnthropicFormat(parsed, toolNames);
+      // Only api.anthropic.com runs Anthropic's server tools, so only it gets their history back.
+      const { system, messages } = messagesToAnthropicFormat(parsed, toolNames,
+        usesNativeAnthropicEndpoint(provider) ? parsed._anthropicServerReplay : undefined);
       // Before image normalization, so the framing block is present for every downstream pass.
       if (isAgentRouterEndpoint(provider.baseUrl)) applyAgentRouterLanguageFraming(messages);
       // Primary image layer: resize/re-encode to fit Anthropic limits without dropping
@@ -1199,7 +1230,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
 
       // Prompt caching: native Anthropic supports top-level automatic caching, which
       // follows the moving final block across turns. Keep one breakpoint slot free for it.
-      const cc = resolveCacheControl(cacheRetention);
+      const cc = resolveCacheControl(cacheRetention, provider);
       const automaticPromptCaching = cc && usesNativeAnthropicEndpoint(provider);
       if (automaticPromptCaching) body.cache_control = cc;
       const explicitLimit = automaticPromptCaching ? MAX_CACHE_BREAKPOINTS - 1 : MAX_CACHE_BREAKPOINTS;
@@ -1210,7 +1241,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
       enforceCacheControlLimit(body, explicitLimit);
       normalizeTtlOrdering(body);
 
-      return {
+      const request = {
         url,
         method: "POST",
         headers,
@@ -1224,6 +1255,8 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
           fastSpeed?.value ?? null,
         ),
       };
+      captureAnthropicRejectionPayloads(request, body, incoming?.translatorBudget);
+      return request;
     },
 
     async *parseStream(
@@ -1236,6 +1269,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         return;
       }
 
+      const replayCapture = createAnthropicReplayCapture(response, budget);
       const budgetEncoder = new TextEncoder();
       let currentBlockType = "";
       let currentToolCallId = "";
@@ -1270,11 +1304,13 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
           yield anthropicContentFilterIncomplete(pendingStopReason, usageFromAnthropic(pendingUsage));
           return;
         }
-        yield {
+        const done: AdapterEvent = {
           type: "done",
           usage: usageFromAnthropic(pendingUsage),
           ...(pendingStopReason ? { stopReason: pendingStopReason } : {}),
         };
+        replayCapture?.finish(done);
+        yield done;
       };
 
       try {
@@ -1294,6 +1330,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         try {
           parsed = JSON.parse(payload);
         } catch {
+          replayCapture?.invalidate();
           debugDroppedFrame("anthropic", payload);
           continue;
         }
@@ -1301,10 +1338,12 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         // it and the `data.type` read below crashed the stream. Drop a non-record frame the same
         // way an unparseable one is dropped, so the message_stop check still governs the outcome.
         if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+          replayCapture?.invalidate();
           debugDroppedFrame("anthropic", payload);
           continue;
         }
         const data = parsed as Record<string, unknown>;
+        replayCapture?.accept({ ...data, type: record.event || data.type });
 
         switch (record.event || data.type) {
               case "message_start": {
@@ -1317,6 +1356,9 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
               case "content_block_start": {
                 const block = data.content_block as { type: string; id?: string; name?: unknown; data?: string; thinking?: string; tool_use_id?: unknown; content?: unknown } | undefined;
                 if (!block) break;
+                // Even an unmodeled server tool or empty block is semantic progress.
+                // Fence replays before a later refusal; unknown blocks must not look like pings.
+                yield { type: "heartbeat", replayUnsafe: true };
                 currentBlockType = block.type;
                 if (block.type === "thinking") {
                   // Preserve even a display:omitted block boundary. The bridge can then
@@ -1336,36 +1378,26 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                   // no result in this response and must not surface as a completed search.
                   serverSearch = { id: block.id, json: "", streaming: true };
                 }
-                if (block.type === "web_search_tool_result" && typeof block.tool_use_id === "string") {
+                if ((block.type === "web_search_tool_result" || block.type === "web_fetch_tool_result") && typeof block.tool_use_id === "string") {
+                  // The begin/end pair the sidecar emits, plus both blocks verbatim so the Claude client holds a
+                  // replayable copy. Without this response's matching call and complete input, drop the
+                  // exchange instead of inventing a call that could poison the client's next request.
+                  const fetch = block.type === "web_fetch_tool_result";
+                  const input = serverSearch?.id === block.tool_use_id ? serverToolInput(serverSearch.json) : undefined;
+                  if (!input) break;
                   const hits = Array.isArray(block.content) ? block.content as Array<{ url?: unknown; title?: unknown }> : undefined;
-                  // The begin/end pair the sidecar emits. A result whose call came in an earlier response has no query here.
-                  const query = serverSearch?.id === block.tool_use_id ? serverToolInputField(serverSearch.json, "query") : "";
                   yield { type: "web_search_call_begin", id: block.tool_use_id };
                   yield {
                     type: "web_search_call_end",
                     id: block.tool_use_id,
-                    queries: query ? [query] : [],
-                    // A failed search carries one error object instead of the hit list.
-                    status: hits ? "completed" : "failed",
+                    queries: typeof input.query === "string" && input.query.length > 0 ? [input.query] : [],
+                    // A failed call carries one error object instead of the hit list / fetched page.
+                    status: (fetch ? (block.content as { type?: unknown } | undefined)?.type === "web_fetch_result" : hits) ? "completed" : "failed",
                     sources: (hits ?? []).flatMap(h => typeof h.url === "string"
                       ? [{ url: h.url, ...(typeof h.title === "string" ? { title: h.title } : {}) }] : []),
-                  };
-                  serverSearch = undefined;
-                }
-                if (block.type === "web_fetch_tool_result" && typeof block.tool_use_id === "string") {
-                  // Relayed as the same cell, opened at the result for the same reason; the result is
-                  // carried verbatim (a web_fetch_result document or a web_fetch_tool_error).
-                  const result = block.content ?? { type: "web_fetch_tool_error", error_code: "unavailable" };
-                  const url = (result as { url?: unknown }).url;
-                  yield { type: "web_search_call_begin", id: block.tool_use_id };
-                  yield {
-                    type: "web_search_call_end",
-                    id: block.tool_use_id,
-                    queries: [],
-                    status: (result as { type?: unknown }).type === "web_fetch_result" ? "completed" : "failed",
-                    fetch: {
-                      url: typeof url === "string" ? url : serverSearch?.id === block.tool_use_id ? serverToolInputField(serverSearch.json, "url") : "",
-                      result,
+                    anthropic: {
+                      use: { type: "server_tool_use", id: block.tool_use_id, name: fetch ? "web_fetch" : "web_search", input },
+                      result: block as Record<string, unknown>,
                     },
                   };
                   serverSearch = undefined;
@@ -1415,8 +1447,8 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                   yield { type: "tool_call_delta", arguments: delta.partial_json };
                 } else if (delta.type === "input_json_delta" && typeof delta.partial_json === "string" && serverSearch?.streaming
                     && serverSearch.json.length < 4096) {
-                  // Capped: an input past 4 KiB loses its label (query / url), never the call.
-                  serverSearch.json += delta.partial_json;
+                  // Capped: input that cannot be recovered drops its exchange instead of inventing a call.
+                  serverSearch.json += delta.partial_json.slice(0, 4096 - serverSearch.json.length);
                 }
                 break;
               }
@@ -1463,8 +1495,13 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                 break;
               }
               case "error": {
-                const err = data.error as { message?: string } | undefined;
-                yield { type: "error", message: err?.message ?? "Anthropic error" };
+                const err = data.error as { message?: unknown; type?: unknown; code?: unknown; status?: unknown } | undefined;
+                yield { type: "error", message: typeof err?.message === "string" ? err.message : "Anthropic error",
+                  ...(typeof err?.type === "string" ? { errorType: err.type } : {}),
+                  ...(typeof err?.code === "string" ? { code: err.code } : {}),
+                  ...(typeof err?.status === "number" && Number.isInteger(err.status) && err.status >= 400 && err.status <= 599
+                    ? { status: err.status } : {}),
+                };
                 return;
               }
         }
@@ -1483,6 +1520,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         // one-terminal-event contract for consumers that keep draining the generator.
         return;
       } finally {
+        replayCapture?.discard();
         if (currentToolCallId) budget.closeCall(currentToolCallId);
       }
       if (!emittedDone) {

package/src/adapters/coding-agent/protocol.ts

@@ -1,6 +1,7 @@
 import { namespacedToolName, type AdapterEvent, type OcxMessage, type OcxParsedRequest, type OcxUsage } from "../../types";
 import type { TranslatorBudget } from "../../lib/translator-budget";
 import { isValidCodingAgentToolNamePart } from "./tool-catalog";
+import { anthropicCacheWrite1hTokens } from "../anthropic/cache-retention";
 
 /**
  * Shared stream-json protocol for official coding-agent CLIs (CodeBuddy Code and Qoder CLI).
@@ -165,6 +166,7 @@ function usageFromAnthropicShape(usage: Record<string, unknown>): OcxUsage | und
   // that could carry those tokens instead, so the turn under-reported usage and cost.
   const cacheReadTotal = count(usage.cache_read_input_tokens);
   const cacheCreationTotal = count(usage.cache_creation_input_tokens);
+  const cacheCreation1h = anthropicCacheWrite1hTokens(usage, cacheCreationTotal);
   const inputTokens = freshInputTokens + cacheReadTotal + cacheCreationTotal;
   if (inputTokens === 0 && outputTokens === 0 && cacheReadTotal === 0 && cacheCreationTotal === 0) {
     return undefined;
@@ -175,6 +177,7 @@ function usageFromAnthropicShape(usage: Record<string, unknown>): OcxUsage | und
     totalTokens: inputTokens + outputTokens,
     ...(cacheReadTotal > 0 ? { cachedInputTokens: cacheReadTotal, cacheReadInputTokens: cacheReadTotal } : {}),
     ...(cacheCreationTotal > 0 ? { cacheCreationInputTokens: cacheCreationTotal } : {}),
+    ...(cacheCreationTotal > 0 && cacheCreation1h !== undefined ? { cacheCreation1hInputTokens: cacheCreation1h } : {}),
   };
 }
 
@@ -204,6 +207,8 @@ function mergePartialUsage(previous: OcxUsage | undefined, next: OcxUsage): OcxU
     next.cacheReadInputTokens ?? next.cachedInputTokens ?? 0,
   );
   const cacheCreation = Math.max(previous.cacheCreationInputTokens ?? 0, next.cacheCreationInputTokens ?? 0);
+  const cacheCreation1h = Math.min(cacheCreation,
+    Math.max(previous.cacheCreation1hInputTokens ?? 0, next.cacheCreation1hInputTokens ?? 0));
   // Inclusive inputs: fold each snapshot's fresh part, then add the folded cache counters once.
   const freshInput = (usage: OcxUsage) => Math.max(0, usage.inputTokens
     - (usage.cacheReadInputTokens ?? usage.cachedInputTokens ?? 0) - (usage.cacheCreationInputTokens ?? 0));
@@ -214,6 +219,7 @@ function mergePartialUsage(previous: OcxUsage | undefined, next: OcxUsage): OcxU
     totalTokens: inputTokens + outputTokens,
     ...(cacheRead > 0 ? { cachedInputTokens: cacheRead, cacheReadInputTokens: cacheRead } : {}),
     ...(cacheCreation > 0 ? { cacheCreationInputTokens: cacheCreation } : {}),
+    ...(cacheCreation1h > 0 ? { cacheCreation1hInputTokens: cacheCreation1h } : {}),
   };
 }
 

package/src/adapters/google-http.ts

@@ -1,3 +1,4 @@
+import { inheritAccountAutoPauseResponse } from "../lib/account-auto-pause-response";
 import type { AdapterFetchContext, AdapterRequest } from "./base";
 import { createAdapterPhysicalSend } from "./physical-send";
 import type { SendClass } from "../lib/request-execution-budget";
@@ -38,10 +39,10 @@ async function normalizeFinalGoogleError(label: string, res: Response, signal?:
     const headers = new Headers(res.headers);
     headers.delete("content-encoding");
     headers.delete("content-length");
-    return new Response(safeGoogleHttpErrorMessage(label, res.status,
+    return inheritAccountAutoPauseResponse(res, new Response(safeGoogleHttpErrorMessage(label, res.status,
       body.displaySafe && !body.truncated ? body.text : ""), {
       status: res.status, statusText: res.statusText, headers,
-    });
+    }));
   }
   return normalizeUpstreamHttpErrorResponse(res, {
     signal,

package/src/adapters/google-progress-history.ts

@@ -0,0 +1,53 @@
+/**
+ * Gemini progress-text history trimming.
+ *
+ * Gemini models, observed on Gemini 4 Argon over Cloud Code Assist, sometimes skip their thinking
+ * channel on a tool-calling turn and plan in the visible text instead. The provider sends that
+ * planning as an ordinary text part without a thought marker, for example a progress line in the
+ * user's language followed by "Let's read google.ts 580-1700 first." Once one turn like that is
+ * replayed as history, the model copies the pattern on the turns that follow, so the leak grows
+ * through the rest of the session. Replaying the same 300K-token request with the leaked tails
+ * removed from the history stopped the leak, while stronger system-prompt wording did not.
+ *
+ * The fix is on the history side only. Text that precedes the tool call of a replayed model turn is
+ * intermediate progress, and the Google brevity instruction already asks for a single short line
+ * there, so it is replayed as its lead sentence. A turn Codex marks `final_answer` and text after a
+ * tool call are replayed whole. Visible output is never rewritten, final
+ * answers (turns without tool calls) are replayed in full, and the split is punctuation-based so
+ * it works the same in every language without matching any wording.
+ */
+
+/**
+ * Sentence end: ASCII terminal punctuation followed by whitespace or the end (so "google.ts" and
+ * "3.5" are not boundaries), a script's own sentence terminator (CJK 。！？, Devanagari
+ * ।॥, Arabic ۔؟, Armenian ։, Ethiopic ።, Myanmar ။), or a line break. Closing quotes, brackets and
+ * Markdown emphasis right after the punctuation belong to the sentence.
+ */
+const SENTENCE_END = /[.!?]["'\u201D\u2019)\]*_`]*(?=\s|$)|[\u3002\uFF01\uFF1F\u0964\u0965\u06D4\u061F\u0589\u1362\u104B]["'\u201D\u2019\u300D\u300F)\]*_`]*|\n/g;
+
+/** A boundary that only closes a leading list marker ("1.", "a.") or a common abbreviation ("e.g."). */
+const NOT_A_SENTENCE = /^(?:\d{1,3}|[a-z])\.$|(?:^|\s)(?:e\.g|i\.e|etc|vs)\.$/i;
+
+/** Whether replayed progress text for this model is trimmed to its lead sentence. */
+export function trimsGeminiProgressHistory(modelId: string): boolean {
+  return /gemini/i.test(modelId);
+}
+
+/**
+ * The lead sentence of a replayed progress text, or undefined when nothing usable remains.
+ * Text without a sentence boundary is already a single sentence and is returned whole.
+ */
+export function geminiProgressLead(text: string): string | undefined {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return undefined;
+  SENTENCE_END.lastIndex = 0;
+  let end = trimmed.length;
+  for (let match = SENTENCE_END.exec(trimmed); match; match = SENTENCE_END.exec(trimmed)) {
+    const boundary = match.index + match[0].length;
+    if (!NOT_A_SENTENCE.test(trimmed.slice(0, boundary).trim())) { end = boundary; break; }
+  }
+  const lead = trimmed.slice(0, end).trim();
+  // A code-fence opener is not a sentence; replaying it alone would leave an unclosed fence.
+  if (lead.length === 0 || lead.startsWith("```")) return undefined;
+  return lead;
+}

package/src/adapters/google-vertex-endpoint.ts

@@ -0,0 +1,67 @@
+import { googleVertexLocationConfigError } from "../providers/google-vertex-location";
+
+/**
+ * Vertex endpoint selection, shared by inference and replay identity.
+ *
+ * API keys follow explicit provider configuration only: `provider.project` selects the project
+ * endpoint (location defaults to `global`), otherwise the projectless express endpoint is used.
+ * Ambient GOOGLE_CLOUD_PROJECT / GCLOUD_PROJECT / GOOGLE_CLOUD_LOCATION belong to ADC, so an
+ * unrelated gcloud default in the shell cannot move an express-mode key onto another project.
+ */
+export type VertexEndpointSelection =
+  | { kind: "express" }
+  | { kind: "project"; project: string; location: string };
+
+type VertexEndpointConfig = { project?: string; location?: string };
+
+export function selectVertexEndpoint(
+  provider: VertexEndpointConfig,
+  hasApiKey: boolean,
+  env: NodeJS.ProcessEnv = process.env,
+): VertexEndpointSelection {
+  // A blank or whitespace-only project is unset: it must not select a /projects/%20/ endpoint.
+  const configuredProject = provider.project?.trim() || undefined;
+  if (hasApiKey) {
+    if (!configuredProject) return { kind: "express" };
+    return { kind: "project", project: configuredProject, location: provider.location || "global" };
+  }
+  const project = configuredProject || env.GOOGLE_CLOUD_PROJECT || 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 || env.GOOGLE_CLOUD_LOCATION;
+  if (!location) throw new Error("Vertex AI requires a location (provider.location or GOOGLE_CLOUD_LOCATION).");
+  return { kind: "project", project, location };
+}
+
+/**
+ * Replay namespace for thought-signature continuation; mirrors the endpoint actually used.
+ * The endpoint kind is part of the key and the project is encoded, so no configured project
+ * (for example one literally named "api-key" or containing ":") can share express mode's space.
+ */
+export function vertexReplayModelKey(selection: VertexEndpointSelection, modelId: string): string {
+  return selection.kind === "express"
+    ? `vertex:express:${modelId}`
+    : `vertex:project:${encodeURIComponent(selection.project)}:${selection.location}:${modelId}`;
+}
+
+const VERTEX_MODEL_PATH_REJECT = /[/?#\\%]/;
+
+/** The model id is interpolated as one URL path segment after a fixed Google authority. */
+export function vertexModelPathError(modelId: string): string | undefined {
+  if (!modelId || VERTEX_MODEL_PATH_REJECT.test(modelId) || modelId.includes("..")) {
+    return "Vertex AI model id must be a single path segment without '/', '?', '#', '\\', '%' or '..'.";
+  }
+  return undefined;
+}
+
+/** Builds the inference URL for a selection; validates location before any authority is formed. */
+export function vertexInferenceUrl(selection: VertexEndpointSelection, modelId: string, method: string, streamParam: string): string {
+  const modelError = vertexModelPathError(modelId);
+  if (modelError) throw new Error(modelError);
+  if (selection.kind === "express") {
+    return `https://aiplatform.googleapis.com/v1/publishers/google/models/${modelId}:${method}${streamParam}`;
+  }
+  const locationError = googleVertexLocationConfigError(selection.location);
+  if (locationError) throw new Error(locationError);
+  const host = selection.location === "global" ? "aiplatform.googleapis.com" : `${selection.location}-aiplatform.googleapis.com`;
+  return `https://${host}/v1/projects/${encodeURIComponent(selection.project)}/locations/${selection.location}/publishers/google/models/${modelId}:${method}${streamParam}`;
+}