mixdog 1.2.2 → 1.2.3

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-events/content-block-start.mjs

@@ -19,7 +19,7 @@ function cloneNativeBlock(block) {
   }
 }
 
-export function createContentBlockStart({ turn, blocks, state, progress }) {
+export function createContentBlockStart({ turn, blocks, state, progress, seedText }) {
   const seedThinkingBlock = (index, block) => {
     if (block.type === 'redacted_thinking') {
       // Opaque redacted payload: real reasoning content, exposed as a block.
@@ -61,9 +61,16 @@ export function createContentBlockStart({ turn, blocks, state, progress }) {
       });
     }
     if (block?.type === 'text') {
-      // Seed the ordered text slot (a text block may open with a non-empty
-      // `text` before any delta).
-      blocks.appendText(index, typeof block.text === 'string' ? block.text : '');
+      // Seed the ordered text slot. An empty block still needs its slot (it
+      // separates thinking runs); a non-empty opening `text` is model output
+      // and is routed exactly like a text_delta so it reaches the returned and
+      // live content once.
+      const initialText = typeof block.text === 'string' ? block.text : '';
+      if (initialText) seedText(index, initialText);
+      else blocks.appendText(index, '');
+      if (Array.isArray(block.citations)) {
+        for (const citation of block.citations) blocks.appendCitation(index, citation);
+      }
     }
     if (NATIVE_SERVER_TOOL_CALL_BLOCK_TYPES.has(block?.type)) {
       // Verbatim seed; `input` is completed from the streamed

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-events/message-events.mjs

@@ -26,6 +26,9 @@ export function createMessageEvents({ turn, blocks, state }) {
     if (event.delta && (event.delta.stop_details != null || event.delta.category != null)) {
       turn.stopDetails = stopDetailsFrom(event.delta);
     }
+    if (event.delta?.stop_sequence != null) {
+      turn.stopSequence = event.delta.stop_sequence;
+    }
     if (event.usage) updateTurnUsage(turn.usage, event.usage);
     // A terminal stop_reason while ANY tool input is still streaming ends the
     // turn truncated, immediately: the model declared it stopped sampling, so

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-events.mjs

@@ -21,18 +21,25 @@ export function createTurnEvents({
   labels,
 }) {
   const { onMessageStart, onMessageDelta, onMessageStop } = createMessageEvents({ turn, blocks, state });
+  const onContentBlockDelta = createContentBlockDelta({
+    turn,
+    blocks,
+    state,
+    leak,
+    relayText,
+    progress,
+    relayProgressUpdates,
+  });
   return {
     onMessageStart,
-    onContentBlockStart: createContentBlockStart({ turn, blocks, state, progress }),
-    onContentBlockDelta: createContentBlockDelta({
+    onContentBlockStart: createContentBlockStart({
       turn,
       blocks,
       state,
-      leak,
-      relayText,
       progress,
-      relayProgressUpdates,
+      seedText: onContentBlockDelta.seedText,
     }),
+    onContentBlockDelta,
     onContentBlockStop: createContentBlockStop({ turn, blocks, state, leak, progress, onToolCall, labels }),
     onMessageDelta,
     onMessageStop,

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-outcome.mjs

@@ -138,6 +138,7 @@ export function createTurnOutcome({ turn, blocks, state, labels = OAUTH_STREAM_L
       usage: turn.usage,
       stopReason: turn.stopReason,
       stopDetails: turn.stopDetails,
+      ...(turn.stopSequence != null ? { stopSequence: turn.stopSequence } : {}),
       hasThinkingContent: turn.hasThinkingContent,
       contentBlockTypes: Array.from(turn.contentBlockTypes),
       // Ordered extended-thinking blocks (verbatim thinking text + signature)

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-state.mjs

@@ -5,6 +5,8 @@
  * module of the turn reads and writes this one object; nothing about the
  * turn's progress is hidden in a closure.
  */
+import { reportedCostUsd } from '../lib/usage-primitives.mjs';
+import { normalizeServerToolUse } from '../lib/anthropic-server-tool-usage.mjs';
 
 export function createAnthropicTurnState() {
   return {
@@ -16,6 +18,9 @@ export function createAnthropicTurnState() {
     usage: { inputTokens: 0, outputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, raw: null },
     stopReason: null,
     stopDetails: undefined,
+    // The custom stop sequence that ended the turn (message_delta
+    // delta.stop_sequence); stays undefined unless the API reports one.
+    stopSequence: undefined,
     fallbackEvents: [],
     // Set when a terminal frame (message_delta stop_reason / message_stop)
     // arrived while tool input was still in flight — used only to word the
@@ -35,6 +40,15 @@ export function updateTurnUsage(usage, raw) {
   if (raw.cache_creation?.ephemeral_1h_input_tokens != null) {
     usage.cacheWrite1hTokens = raw.cache_creation.ephemeral_1h_input_tokens;
   }
+  // A gateway's reported cost (OpenRouter puts `cost` on the final usage). It
+  // rides the turn usage itself, so a success, an abandoned attempt and a
+  // failure's partial usage all carry it to the provider-boundary ledger.
+  const costUsd = reportedCostUsd(raw.cost);
+  if (costUsd !== undefined) usage.costUsd = costUsd;
+  // Server-tool counters are cumulative in message_delta; a later report
+  // replaces the earlier one, an absent one preserves it.
+  const serverToolUse = normalizeServerToolUse(raw);
+  if (serverToolUse) usage.serverToolUse = serverToolUse;
   usage.raw = { ...(usage.raw || {}), ...raw };
   // Input excludes cache; all three slots contribute to prompt volume.
   usage.promptTokens = usage.inputTokens + usage.cachedTokens + usage.cacheWriteTokens;

package/src/runtime/agent/orchestrator/providers/anthropic-sse.mjs

@@ -75,9 +75,11 @@ const ANTHROPIC_SSE_ERROR_TYPE_STATUS = new Map([
   ['authentication_error', 401],
   ['permission_error', 403],
   ['not_found_error', 404],
+  ['conflict_error', 409],
   ['request_too_large', 413],
   ['rate_limit_error', 429],
   ['api_error', 500],
+  ['timeout_error', 504],
   ['overloaded_error', 529],
 ]);
 

package/src/runtime/agent/orchestrator/providers/anthropic-turn-result.mjs

@@ -10,6 +10,7 @@
  * account for usage identically.
  */
 import { traceAgentUsage } from '../agent-trace.mjs';
+import { reportedCostUsd } from './lib/usage-primitives.mjs';
 
 /**
  * @param {object} parseResult  the assembled turn (streaming or normalized non-streaming)
@@ -26,6 +27,7 @@ export function buildAnthropicTurnResult(parseResult, { provider, useModel, opts
   const output = parseResult.usage?.outputTokens || 0;
   const promptTokens = parseResult.usage?.promptTokens ?? input + cacheRead + cacheWrite;
   const liveModel = parseResult.model || useModel;
+  const costUsd = parseResult.usage?.costUsd ?? reportedCostUsd(usageRaw?.cost);
 
   if (usageRaw || input || output || cacheRead || cacheWrite) {
     traceAgentUsage({
@@ -53,6 +55,8 @@ export function buildAnthropicTurnResult(parseResult, { provider, useModel, opts
     model: liveModel,
     toolCalls: parseResult.toolCalls,
     stopReason: parseResult.stopReason || null,
+    ...(parseResult.stopDetails != null ? { stopDetails: parseResult.stopDetails } : {}),
+    ...(parseResult.stopSequence != null ? { stopSequence: parseResult.stopSequence } : {}),
     hasThinkingContent: !!parseResult.hasThinkingContent,
     contentBlockTypes: Array.isArray(parseResult.contentBlockTypes) ? parseResult.contentBlockTypes : [],
     // Round-trip adaptive-thinking blocks (verbatim thinking +
@@ -84,6 +88,11 @@ export function buildAnthropicTurnResult(parseResult, { provider, useModel, opts
       cacheWriteTokens: cacheWrite,
       ...(parseResult.usage?.cacheWrite1hTokens ? { cacheWrite1hTokens: parseResult.usage.cacheWrite1hTokens } : {}),
       promptTokens,
+      // A gateway-reported cost (OpenRouter `usage.cost`), when the turn has one.
+      ...(costUsd !== undefined ? { costUsd } : {}),
+      ...(parseResult.usage?.serverToolUse ? { serverToolUse: parseResult.usage.serverToolUse } : {}),
+      // Raw provider usage (incl. server_tool_use counters), as on the OAuth path.
+      ...(usageRaw ? { raw: usageRaw } : {}),
     },
   };
 }

package/src/runtime/agent/orchestrator/providers/anthropic.mjs

@@ -83,6 +83,11 @@ export class AnthropicProvider {
       maxRetries: 0,
     });
   }
+  // The model id capability lookups (output cap, thinking/effort shape) read;
+  // a gateway engine maps its routing slug to the Claude id it stands for.
+  _capabilityModel(model) {
+    return model;
+  }
   reloadApiKey() {
     try {
       const newKey = reloadProviderApiKey(this.name, this.config);
@@ -149,6 +154,7 @@ export class AnthropicProvider {
       fastModeLatched: this.fastModeBetaHeaderLatched,
       // Custom providers carry per-model reasoning settings on their own rows.
       modelInfo: isCustomProviderName(this.name) ? this.getCachedModelInfo?.(useModel) || null : null,
+      capabilityModel: this._capabilityModel(useModel),
     });
     this.fastModeBetaHeaderLatched = fastModeLatched;
 

package/src/runtime/agent/orchestrator/providers/antigravity-request.mjs

@@ -15,6 +15,12 @@ export function isAntigravityClaude(model) {
   return /^claude-/i.test(String(model || ''));
 }
 
+// Claude declarations are validated for the gateway's Anthropic bridge in
+// toGeminiTools (claudeBridge: true); a tool with an invalid schema is left
+// out of the request and reported through `onToolExcluded` / console.warn.
+const claudeRequestTools = (tools, nativeTools, onToolExcluded) =>
+  toGeminiRequestTools(tools, nativeTools, { claudeBridge: true, onToolExcluded });
+
 // Default function-calling mode when the caller sets no toolChoice. VALIDATED
 // (schema-constrained function calls) is what the Antigravity client sends;
 // MIXDOG_ANTIGRAVITY_FC_MODE=AUTO|ANY|VALIDATED overrides it for A/B runs.
@@ -35,14 +41,52 @@ function replayFamilyMatches(message, model) {
   return isAntigravityClaude(recorded) === isAntigravityClaude(model);
 }
 
+// The stream records empty text parts around Claude tool calls; Cloud Code's
+// Claude bridge rejects them on replay ("text.text: Field required").
+const isEmptyPlainTextPart = (part) =>
+  part?.text === '' && part.thought !== true && typeof part.thoughtSignature !== 'string';
+
+// Streamed Claude thinking arrives as many thought deltas with the signature
+// on the closing (often empty) delta; the bridge turns every part into its own
+// thinking block and rejects the unsigned ones ("thinking.signature: Field
+// required"). Rejoin each run into one block that ends at its signature.
+function coalesceClaudeThoughts(parts) {
+  const out = [];
+  let open = null;
+  for (const part of parts) {
+    if (part?.thought !== true) {
+      if (open) out.push(open);
+      open = null;
+      out.push(part);
+      continue;
+    }
+    open = open
+      ? { ...open, ...part, text: `${open.text}${typeof part.text === 'string' ? part.text : ''}` }
+      : { ...part, text: typeof part.text === 'string' ? part.text : '' };
+    if (typeof part.thoughtSignature === 'string') {
+      out.push(open);
+      open = null;
+    }
+  }
+  if (open) out.push(open);
+  return out;
+}
+
 function signatureSafeMessages(messages, model) {
-  return messages.map((message) => {
-    if (message?.role !== 'assistant') return message;
+  const claude = isAntigravityClaude(model);
+  return messages.flatMap((message) => {
+    if (message?.role !== 'assistant') return [message];
     const ownParts = replayFamilyMatches(message, model) ? providerReplayItems(message, 'antigravity') : undefined;
     // Repair tool signatures only after the complete history establishes
     // the active turn, not while normalizing an isolated older message.
-    const parts = ownParts || toGeminiContents([message], model, { repairToolSignatures: false })[0]?.parts;
-    if (!parts?.length) return message;
+    const sourceParts = ownParts || toGeminiContents([message], model, { repairToolSignatures: false })[0]?.parts;
+    const parts =
+      claude && sourceParts
+        ? coalesceClaudeThoughts(sourceParts.filter((part) => !isEmptyPlainTextPart(part)))
+        : sourceParts;
+    // A turn that held only empty parts is omitted, not sent as parts:[].
+    if (sourceParts?.length && !parts.length) return [];
+    if (!parts?.length) return [message];
     for (const part of parts) {
       if (!part || typeof part !== 'object') continue;
       if (part.thought === true || typeof part.thoughtSignature === 'string') {
@@ -52,7 +96,7 @@ function signatureSafeMessages(messages, model) {
         if (!ownParts || !part.thoughtSignature) part.thoughtSignature = THOUGHT_SIGNATURE_SENTINEL;
       }
     }
-    return { ...message, providerReplay: createProviderReplay('antigravity', parts) };
+    return [{ ...message, providerReplay: createProviderReplay('antigravity', parts) }];
   });
 }
 
@@ -121,9 +165,16 @@ export function buildAntigravityRequest(messages, model, tools, opts = {}, proje
   };
   const request = { contents };
   if (systemText) request.systemInstruction = { role: 'user', parts: [{ text: systemText }] };
-  const requestTools = toGeminiRequestTools(tools, opts.nativeTools);
+  const requestTools = claude
+    ? claudeRequestTools(tools, opts.nativeTools, opts.onToolExcluded)
+    : toGeminiRequestTools(tools, opts.nativeTools, {
+        onToolExcluded: opts.onToolExcluded,
+        // Other families (GPT-OSS) keep the plain conversion.
+        validate: isGeminiFamilyModel(model),
+      });
   if (requestTools.length) request.tools = requestTools;
-  if (tools?.length) {
+  // Tool config only accompanies function declarations that were kept.
+  if (requestTools.some((entry) => entry.functionDeclarations?.length)) {
     request.toolConfig = toGeminiToolConfig(opts.toolChoice) || {
       functionCallingConfig: { mode: antigravityFunctionCallingMode() },
     };

package/src/runtime/agent/orchestrator/providers/antigravity-response.mjs

@@ -8,13 +8,20 @@
  */
 import { traceAgentUsage } from '../agent-trace.mjs';
 import { createProviderReplay } from './lib/provider-replay.mjs';
-import { parseToolCalls, collectGeminiGroundingSources, parseGeminiTextPartMetadata } from './gemini-schema.mjs';
-import { geminiPolicyFinishCode } from './gemini-error-contract.mjs';
+import {
+  parseToolCalls,
+  emitGeminiToolCalls,
+  collectGeminiGroundingSources,
+  parseGeminiTextPartMetadata,
+} from './gemini-schema.mjs';
+import { geminiFinishErrorFields, geminiPolicyFinishCode } from './gemini-error-contract.mjs';
 
 // Pure usageMetadata normalization shared by the success path and a failed
 // stream's partialUsage.
 export function normalizeAntigravityUsage(um) {
-  const inputTokens = um.promptTokenCount || um.prompt_token_count || 0;
+  const inputTokens =
+    (um.promptTokenCount || um.prompt_token_count || 0) +
+    (um.toolUsePromptTokenCount || um.tool_use_prompt_token_count || 0);
   const cachedTokens = um.cachedContentTokenCount || um.cached_content_token_count || 0;
   const outputTokens =
     (um.candidatesTokenCount || um.candidates_token_count || 0) +
@@ -28,7 +35,7 @@ export function normalizeAntigravityUsage(um) {
  * @param {ReturnType<import('./antigravity-stream.mjs').createAntigravityStreamCollector>} deps.collector
  * @param {string} deps.useModel  wire model id
  * @param {object} deps.opts  send options (session/iteration/providerState)
- * @param {Function|null} deps.onToolCall  set when calls were streamed live
+ * @param {Function|null} deps.onToolCall  receives the turn's calls after a clean finish
  */
 export function finalizeAntigravityTurn({ response, collector, useModel, opts, onToolCall }) {
   const textLeakGuard = collector.leakGuard;
@@ -46,10 +53,8 @@ export function finalizeAntigravityTurn({ response, collector, useModel, opts, o
   // Thought signatures are only valid for the model family that minted
   // them; the request builder consults this when the route changes.
   if (providerReplay) providerReplay.requestContext = { model: useModel };
-  let nativeToolCalls;
-  if (!onToolCall) nativeToolCalls = parseToolCalls(responseParts);
-  else if (collector.streamedNativeToolCalls.length) nativeToolCalls = collector.streamedNativeToolCalls;
-  if (!onToolCall && textLeakGuard?.enabled) nativeToolCalls = textLeakGuard.filterNativeToolCalls(nativeToolCalls);
+  let nativeToolCalls = parseToolCalls(responseParts);
+  if (textLeakGuard?.enabled) nativeToolCalls = textLeakGuard.filterNativeToolCalls(nativeToolCalls);
   let toolCalls = nativeToolCalls;
   if (leakedToolCalls.length) {
     toolCalls = toolCalls?.length ? [...toolCalls, ...leakedToolCalls] : leakedToolCalls;
@@ -80,7 +85,17 @@ export function finalizeAntigravityTurn({ response, collector, useModel, opts, o
     });
   }
 
-  if (finishReason && normalizedFinish !== 'STOP') {
+  // A MAX_TOKENS cut that still delivered whole native functionCall parts is
+  // a tool-use turn: the calls arrived intact, only trailing output was cut.
+  // Every other non-STOP finish fails the turn, and so does a cut whose text
+  // also leaked a call (that call may be as truncated as the text around it).
+  const completeNativeCalls =
+    normalizedFinish === 'MAX_TOKENS' &&
+    String(candidate?.finishReason || '').replace(/^FINISH_REASON_/, '') === 'MAX_TOKENS' &&
+    !leakedToolCalls.length &&
+    !!nativeToolCalls?.length &&
+    nativeToolCalls.every((call) => typeof call?.name === 'string' && call.name !== '');
+  if (finishReason && normalizedFinish !== 'STOP' && !completeNativeCalls) {
     throw Object.assign(new Error(`Antigravity response incomplete: finishReason=${finishReason}`), {
       name: 'ProviderIncompleteError',
       code: geminiPolicyFinishCode(finishReason) || 'PROVIDER_INCOMPLETE',
@@ -93,10 +108,14 @@ export function finalizeAntigravityTurn({ response, collector, useModel, opts, o
       model: useModel,
       rawUsage: response.usageMetadata || null,
       ...(usage ? { partialUsage: usage, partialModel: useModel } : {}),
-      ...(collector.emittedToolCount ? { emittedToolCall: true, unsafeToRetry: true } : {}),
+      ...geminiFinishErrorFields(response),
     });
   }
 
+  // Terminal status first: a failed turn never runs its tool calls.
+  textLeakGuard?.releaseDeferredToolCalls();
+  emitGeminiToolCalls(nativeToolCalls, onToolCall);
+
   return {
     content,
     model: useModel,

package/src/runtime/agent/orchestrator/providers/antigravity-retry-policy.mjs

@@ -4,7 +4,8 @@
  *
  *   capacity (429/503/529, MODEL_CAPACITY_EXHAUSTED, "server busy"): retried on
  *     the SAME account and host with 1s → 2s → 4s (8s cap) ±10% jitter, three
- *     retries, whatever wait the server names, then the failure surfaces.
+ *     retries, waiting at least the server's RetryInfo delay; advice that
+ *     would push total waiting past 60s surfaces the error (with resetAt).
  *   Endpoint: the reference falls back to its next endpoint after a failure;
  *     generation here deliberately stays on the single daily host and never
  *     walks an endpoint list (a spent ladder surfaces to the account layer).
@@ -23,6 +24,8 @@ export const ANTIGRAVITY_CAPACITY_RETRIES = 3;
 export const ANTIGRAVITY_CAPACITY_BASE_MS = 1000;
 export const ANTIGRAVITY_CAPACITY_MAX_MS = 8000;
 export const ANTIGRAVITY_CAPACITY_JITTER_RATIO = 0.1;
+// Total time capacity retries may spend waiting on server-advised delays.
+export const ANTIGRAVITY_CAPACITY_BUDGET_MS = 60_000;
 export const ANTIGRAVITY_QUICK_RETRY_MS = 1000;
 export const ANTIGRAVITY_QUICK_RETRY_MAX_ADVICE_MS = 60_000;
 
@@ -60,10 +63,20 @@ export function antigravity429WaitMs(err, state) {
   if (DETERMINISTIC_KINDS.has(kind) || err.code === 'quota_exhausted' || err.quotaScope === 'day' || err.quotaScope === 'plan') {
     return null;
   }
-  // Capacity follows the local schedule whatever wait the server names.
+  // Capacity waits at least the advised RetryInfo delay (the local schedule
+  // is the floor). Total advised waiting stays within the retry budget; an
+  // advice that does not fit surfaces with its reset time rather than
+  // retrying early.
   if (capacity) {
     if (state.capacityRetries >= ANTIGRAVITY_CAPACITY_RETRIES) return null;
-    return antigravityCapacityDelayMs(state.capacityRetries++);
+    const spent = state.capacityWaitedMs ?? 0;
+    if (retryAfterMs != null && spent + retryAfterMs > ANTIGRAVITY_CAPACITY_BUDGET_MS) {
+      err.resetAt ??= Date.now() + retryAfterMs;
+      return null;
+    }
+    const wait = Math.max(antigravityCapacityDelayMs(state.capacityRetries++), retryAfterMs ?? 0);
+    state.capacityWaitedMs = spent + wait;
+    return wait;
   }
   // An RPM hit gets one quick retry; advice up to a minute is honored in
   // full, a longer wait surfaces so the account pool can rotate.

package/src/runtime/agent/orchestrator/providers/antigravity-stream.mjs

@@ -1,18 +1,15 @@
 /**
  * antigravity-stream.mjs — what one Antigravity SSE turn accumulates while it
  * streams: the live text mirror a retirement notice is recognised from, the
- * ordered parts of every chunk, the native tool calls parsed per chunk with
- * their id dedup, the leak guard that recovers calls the model wrote as text,
- * the first terminal finishReason, and the exposure marks a failed stream must
- * carry (emittedToolCall / unsafeToRetry / partial calls + partial replay).
+ * leak guard that recovers calls the model wrote as text (held back, like the
+ * native calls, until the turn finishes cleanly), and the first terminal
+ * finishReason. Nothing is dispatched while streaming.
  *
  * The transport (antigravity-transport.mjs) owns the socket and the retry
  * policy; the projection (antigravity-response.mjs) reads this record after
  * the turn settles.
  */
-import { createProviderReplay } from './lib/provider-replay.mjs';
 import { createGeminiTextLeakGuard, consumeGeminiRestStreamResponse } from './gemini-stream.mjs';
-import { parseToolCalls, emitGeminiToolCalls } from './gemini-schema.mjs';
 import { normalizeAntigravityUsage } from './antigravity-response.mjs';
 
 // A retired wire id answers with one plain-text notice and no finishReason.
@@ -46,10 +43,6 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
   // Streamed text is kept so a retirement notice can be told apart from
   // a truncated stream when the gateway omits the finishReason.
   let streamedText = '';
-  let streamedParts = [];
-  let streamedNativeToolCalls = [];
-  const seenNativeToolIds = new Set();
-  const emittedToolIds = new Set();
 
   const relayText = onTextDelta
     ? (text) => {
@@ -57,15 +50,9 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
         onTextDelta(text);
       }
     : null;
-  const dispatchToolCall = onToolCall
-    ? (call) => {
-        // A failure already observed in this chunk must win over both
-        // native calls and calls recovered from its text.
-        if (terminalFailure || emittedToolIds.has(call.id)) return;
-        emittedToolIds.add(call.id);
-        onToolCall(call);
-      }
-    : null;
+  // Tool calls (native and text-recovered) are never dispatched while the
+  // stream runs: the turn's terminal verdict decides, and
+  // finalizeAntigravityTurn releases them only after a clean finish.
   const onChunk = (chunk) => {
     const candidate = chunk?.candidates?.[0];
     const finishReason =
@@ -74,37 +61,20 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
     if (finishReason && String(finishReason).replace(/^FINISH_REASON_/, '') !== 'STOP') {
       terminalFailure ||= finishReason;
     }
-    if (!onToolCall) return;
-    const parts = candidate?.content?.parts ?? [];
-    streamedParts.push(...parts);
-    if (terminalFailure || !parts.some((part) => part?.functionCall)) return;
-    // Parse against the turn's parts so anonymous call IDs keep the
-    // same ordinal as final parsing, even across separate SSE chunks.
-    const fresh = (parseToolCalls(streamedParts) || []).filter((call) => {
-      if (seenNativeToolIds.has(call.id)) return false;
-      seenNativeToolIds.add(call.id);
-      return true;
-    });
-    const calls = textLeakGuard?.enabled ? textLeakGuard.filterNativeToolCalls(fresh) : fresh;
-    if (calls?.length) streamedNativeToolCalls.push(...calls);
-    emitGeminiToolCalls(calls, dispatchToolCall);
   };
 
   // Each attempt starts from an empty record: a replayed request must not
-  // inherit the dead attempt's text, parts or dispatched-call ids.
+  // inherit the dead attempt's text or failure.
   const beginAttempt = () => {
     textLeakGuard = createGeminiTextLeakGuard({
       knownToolNames: tools?.map((t) => t.name).filter(Boolean) ?? [],
       onTextDelta: relayText,
-      onToolCall: dispatchToolCall,
+      onToolCall,
       onStreamDelta,
+      deferToolCalls: true,
     });
     streamedText = '';
     terminalFailure = null;
-    streamedParts = [];
-    streamedNativeToolCalls = [];
-    seenNativeToolIds.clear();
-    emittedToolIds.clear();
   };
   const releaseGuard = () => {
     textLeakGuard = null;
@@ -125,22 +95,7 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
         unwrapChunk: (chunk) => (chunk && typeof chunk === 'object' && chunk.response ? chunk.response : chunk),
       });
     } catch (streamErr) {
-      const error = retiredModelError(streamErr, streamedText, useModel) || streamErr;
-      // Native calls now run before EOF. Preserve
-      // their history and prohibit resampling after
-      // a tool callback.
-      if (emittedToolIds.size) {
-        error.emittedToolCall = true;
-        error.unsafeToRetry = true;
-        const leaked = textLeakGuard.getLeakedToolCalls();
-        error.partialToolCalls = [...streamedNativeToolCalls, ...leaked];
-        const replay = createProviderReplay('antigravity', leaked.length ? [] : streamedParts);
-        if (replay) {
-          replay.requestContext = { model: useModel };
-          error.partialProviderReplay = replay;
-        }
-      }
-      throw error;
+      throw retiredModelError(streamErr, streamedText, useModel) || streamErr;
     }
   };
 
@@ -155,11 +110,5 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
     get terminalFailure() {
       return terminalFailure;
     },
-    get streamedNativeToolCalls() {
-      return streamedNativeToolCalls;
-    },
-    get emittedToolCount() {
-      return emittedToolIds.size;
-    },
   };
 }

package/src/runtime/agent/orchestrator/providers/antigravity-transport.mjs

@@ -70,13 +70,19 @@ export function antigravityError(res, text, endpoint) {
   // Account verification is terminal and actionable: surface the URL Google
   // returns instead of a raw API body the user cannot act on.
   // Google puts the link in the error details, not the message text.
-  const validationDetail = Array.isArray(detail?.details)
-    ? detail.details.find(
-        (entry) => entry?.reason === 'VALIDATION_REQUIRED' && typeof entry.metadata?.validation_url === 'string'
-      )
-    : null;
+  // Order: google.rpc.Help.links, metadata.validation_url, metadata.validation_link.
+  const detailEntries = Array.isArray(detail?.details) ? detail.details : [];
+  const helpUrl = detailEntries
+    .flatMap((entry) => (Array.isArray(entry?.links) ? entry.links : []))
+    .map((link) => link?.url)
+    .find((url) => typeof url === 'string' && url.length > 0);
+  const metadataUrl = (key) =>
+    detailEntries.find((entry) => entry?.reason === 'VALIDATION_REQUIRED' && typeof entry.metadata?.[key] === 'string' && entry.metadata[key])
+      ?.metadata[key];
   const validationUrl =
-    validationDetail?.metadata.validation_url ||
+    helpUrl ||
+    metadataUrl('validation_url') ||
+    metadataUrl('validation_link') ||
     /https:\/\/\S*(?:accounts|console)\.google\.com\/\S+/.exec(message || '')?.[0] ||
     '';
   if (res.status === 403 && /VALIDATION_REQUIRED/i.test(text || '')) {

package/src/runtime/agent/orchestrator/providers/codex-client-meta.mjs

@@ -20,7 +20,7 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // version (gpt-6.1-sol requires >= 0.159.0, measured 2026-10-09), so the
 // release workflow raises this to the published CLI version on every release
 // (scripts/sync-client-version-floors.mjs).
-export const CODEX_CLIENT_VERSION_FLOOR = '0.162.1';
+export const CODEX_CLIENT_VERSION_FLOOR = '0.163.0';
 export const CODEX_CLI_NPM_PACKAGE = '@openai/codex';
 const live = createNpmVersionSource(CODEX_CLI_NPM_PACKAGE, { persistKey: 'codex-cli' });