mixdog 1.2.2 → 1.2.3

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

@@ -26,7 +26,11 @@ import { createSdkStreamReader } from './gemini-sdk-stream/reader.mjs';
 import { createRestStreamWatchdogs } from './gemini-rest-stream/watchdogs.mjs';
 import { drainSseDataLines, sseDataPayload } from './gemini-rest-stream/sse-lines.mjs';
 import { noteAbandonedUsage } from '../../../shared/llm/usage-context.mjs';
-import { applyGeminiErrorContract, assertNoGeminiInBandError } from './gemini-error-contract.mjs';
+import {
+  applyGeminiErrorContract,
+  assertNoGeminiInBandError,
+  geminiFinishReasonKind,
+} from './gemini-error-contract.mjs';
 
 export const GEMINI_FIRST_BYTE_TIMEOUT_MS = resolveTimeoutMs(
   'MIXDOG_GEMINI_FIRST_BYTE_TIMEOUT_MS',
@@ -183,8 +187,10 @@ function stampGeminiStreamFailure(
   const visible = visibleText.length > 0;
   // Native functionCall chunks are only dispatched after successful stream
   // completion in gemini.mjs. Until then a reconnect is safe. Text-leaked
-  // calls are dispatched while parsing and remain a hard replay boundary.
-  const pendingTool = leaked;
+  // calls are dispatched while parsing and remain a hard replay boundary,
+  // unless the guard holds them back (`deferToolCalls`): a held call never
+  // runs when the stream fails, so a reconnect cannot double-execute it.
+  const pendingTool = leaked && textLeakGuard?.defersToolCalls !== true;
   try {
     if (visible) {
       err.liveTextEmitted = true;
@@ -237,24 +243,31 @@ function aggregateGeminiStreamChunks(responses, label = 'Gemini stream') {
   // An error envelope anywhere in the stream — including after STOP — fails
   // the turn instead of aggregating into a success.
   for (const response of responses) assertNoGeminiInBandError(response, label);
-  const lastResponse = responses[responses.length - 1];
-  const aggregatedResponse = {
-    promptFeedback: lastResponse?.promptFeedback,
-  };
+  const aggregatedResponse = {};
+  // Candidates are keyed by their own `index`; chunks that omit it fall back
+  // to the position inside that chunk's candidate list.
+  const candidatesByIndex = new Map();
   for (const response of responses) {
+    // Early block info must survive later chunks that carry none.
+    if (response?.promptFeedback) {
+      aggregatedResponse.promptFeedback = { ...aggregatedResponse.promptFeedback, ...response.promptFeedback };
+    }
     if (response?.candidates) {
-      let candidateIndex = 0;
-      for (const candidate of response.candidates) {
-        if (!aggregatedResponse.candidates) aggregatedResponse.candidates = [];
-        if (!aggregatedResponse.candidates[candidateIndex]) {
-          aggregatedResponse.candidates[candidateIndex] = { index: candidateIndex };
+      response.candidates.forEach((candidate, position) => {
+        const candidateIndex = Number.isInteger(candidate?.index) ? candidate.index : position;
+        if (!candidatesByIndex.has(candidateIndex)) candidatesByIndex.set(candidateIndex, { index: candidateIndex });
+        const aggCand = candidatesByIndex.get(candidateIndex);
+        // A later chunk that omits a field never erases an earlier value.
+        if (candidate.citationMetadata !== undefined) {
+          aggCand.citationMetadata = mergeStreamMetadata(aggCand.citationMetadata, candidate.citationMetadata);
         }
-        const aggCand = aggregatedResponse.candidates[candidateIndex];
-        aggCand.citationMetadata = candidate.citationMetadata;
-        aggCand.groundingMetadata = candidate.groundingMetadata;
-        aggCand.finishReason = candidate.finishReason;
-        aggCand.finishMessage = candidate.finishMessage;
-        aggCand.safetyRatings = candidate.safetyRatings;
+        if (candidate.groundingMetadata !== undefined) {
+          aggCand.groundingMetadata = mergeStreamMetadata(aggCand.groundingMetadata, candidate.groundingMetadata);
+        }
+        if (geminiFinishReasonKind(candidate.finishReason) !== 'none') aggCand.finishReason = candidate.finishReason;
+        if (candidate.finishMessage !== undefined) aggCand.finishMessage = candidate.finishMessage;
+        if (candidate.safetyRatings !== undefined) aggCand.safetyRatings = candidate.safetyRatings;
+        if (candidate.continuationToken !== undefined) aggCand.continuationToken = candidate.continuationToken;
         if (candidate.content?.parts) {
           if (!aggCand.content) {
             aggCand.content = {
@@ -273,36 +286,52 @@ function aggregateGeminiStreamChunks(responses, label = 'Gemini stream') {
             aggCand.content.parts.push(newPart);
           }
         }
-        candidateIndex++;
-      }
+      });
     }
     if (response?.usageMetadata) aggregatedResponse.usageMetadata = response.usageMetadata;
   }
+  if (candidatesByIndex.size) {
+    aggregatedResponse.candidates = [...candidatesByIndex.values()].sort((a, b) => a.index - b.index);
+  }
   return aggregatedResponse;
 }
 
-// A response with neither text nor a tool call (thoughts alone are not text).
-function hasNoAnswerContent(aggregated) {
-  const parts = aggregated?.candidates?.[0]?.content?.parts;
-  return !(Array.isArray(parts) ? parts : []).some(
-    (part) => part?.functionCall || (part?.thought !== true && typeof part?.text === 'string' && part.text.trim())
-  );
+// GroundingMetadata / CitationMetadata arrive in pieces while streaming and
+// are merged, not replaced: groundingChunks carry only the chunks not sent
+// before (appended as-is, so groundingSupports indices stay valid); every
+// other list is a de-duplicated union, nested objects merge, scalars take the
+// latest value.
+function mergeStreamMetadata(previous, next) {
+  if (!previous) return next;
+  if (!next || typeof next !== 'object') return previous;
+  const merged = { ...previous };
+  for (const [key, value] of Object.entries(next)) {
+    if (value === undefined || value === null) continue;
+    const before = previous[key];
+    if (Array.isArray(value)) {
+      if (key === 'groundingChunks') {
+        merged[key] = [...(before || []), ...value];
+      } else {
+        const seen = new Set((before || []).map((item) => JSON.stringify(item)));
+        merged[key] = [...(before || []), ...value.filter((item) => !seen.has(JSON.stringify(item)))];
+      }
+    } else if (typeof value === 'object' && before && typeof before === 'object') {
+      merged[key] = { ...before, ...value };
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
 }
 
-function assertGeminiStreamCompleted({
-  sawStreamChunk,
-  finishReason,
-  promptBlockReason,
-  label,
-  acceptEmptyNoFinish = false,
-  aggregated = null,
-}) {
+// A stream that ends with no finishReason is unfinished, whatever it carried
+// (thoughts only, an empty body, even right after a tool result); only a
+// STOP that carries no text is a completed, empty answer.
+function assertGeminiStreamCompleted({ sawStreamChunk, finishReason, promptBlockReason, label }) {
   if (!sawStreamChunk) {
     throw geminiTruncatedStreamError(`${label} truncated: empty stream`);
   }
-  if (!finishReason && !promptBlockReason) {
-    // Right after a tool result the model may end with nothing at all.
-    if (acceptEmptyNoFinish && hasNoAnswerContent(aggregated)) return;
+  if (geminiFinishReasonKind(finishReason) === 'none' && geminiFinishReasonKind(promptBlockReason) === 'none') {
     throw geminiTruncatedStreamError(`${label} truncated: no finishReason`);
   }
 }
@@ -344,13 +373,23 @@ function relayGeminiStreamText(t, { onTextDelta, textLeakGuard }) {
  * `part.text` streams. Mirrors the Anthropic OAuth guard: suppress tags from
  * visible text, synthesize known-tool calls, dispatch via onToolCall.
  */
-export function createGeminiTextLeakGuard({ knownToolNames, onTextDelta, onToolCall, onStreamDelta }) {
+export function createGeminiTextLeakGuard({
+  knownToolNames,
+  onTextDelta,
+  onToolCall,
+  onStreamDelta,
+  deferToolCalls = false,
+}) {
   const _knownTools = knownToolNameSet(knownToolNames);
   const _enabled = _knownTools.size > 0;
   const _isKnownTool = (name) => _knownTools.has(name);
   let leakBuffer = '';
   let relayedText = '';
   const leakedCalls = [];
+  // With `deferToolCalls`, recovered calls wait here until the caller has seen
+  // the response finish cleanly (releaseDeferredToolCalls); a failed response
+  // never runs them.
+  const deferredCalls = [];
   const dispatchedFingerprints = new Set();
 
   const dispatchLeakedCall = (recovered) => {
@@ -372,9 +411,12 @@ export function createGeminiTextLeakGuard({ knownToolNames, onTextDelta, onToolC
       arguments: args,
     };
     leakedCalls.push(call);
-    try {
-      onToolCall?.(call);
-    } catch {}
+    if (deferToolCalls) deferredCalls.push(call);
+    else {
+      try {
+        onToolCall?.(call);
+      } catch {}
+    }
     try {
       onStreamDelta?.('tool');
     } catch {}
@@ -401,6 +443,9 @@ export function createGeminiTextLeakGuard({ knownToolNames, onTextDelta, onToolC
     get enabled() {
       return _enabled;
     },
+    get defersToolCalls() {
+      return deferToolCalls === true;
+    },
     feedText(text) {
       if (!text) return;
       if (!_enabled) {
@@ -439,6 +484,13 @@ export function createGeminiTextLeakGuard({ knownToolNames, onTextDelta, onToolC
     getLeakedToolCalls() {
       return [...leakedCalls];
     },
+    releaseDeferredToolCalls() {
+      for (const call of deferredCalls.splice(0)) {
+        try {
+          onToolCall?.(call);
+        } catch {}
+      }
+    },
     getRelayedText() {
       return relayedText;
     },
@@ -473,7 +525,6 @@ export async function consumeGeminiRestStreamResponse(
     unwrapChunk = null,
     onChunk = null,
     failureUsage = null,
-    acceptEmptyNoFinish = false,
   }
 ) {
   const unwrap =
@@ -613,8 +664,6 @@ export async function consumeGeminiRestStreamResponse(
       finishReason,
       promptBlockReason,
       label,
-      acceptEmptyNoFinish,
-      aggregated,
     });
   } catch (err) {
     throw stampGeminiStreamFailure(err, { relayedText, textLeakGuard, chunks: allChunks, failureUsage });
@@ -634,7 +683,6 @@ export async function consumeGeminiSdkStream(
     firstByteTimeoutMs = GEMINI_FIRST_BYTE_TIMEOUT_MS,
     cancellationGraceMs = 250,
     failureUsage = null,
-    acceptEmptyNoFinish = false,
   }
 ) {
   let relayedText = '';
@@ -721,8 +769,6 @@ export async function consumeGeminiSdkStream(
       finishReason,
       promptBlockReason,
       label,
-      acceptEmptyNoFinish,
-      aggregated: raw,
     });
     return raw;
   } catch (err) {

package/src/runtime/agent/orchestrator/providers/gemini-thinking.mjs

@@ -15,14 +15,53 @@ function catalogThinkingLevels(model, provider) {
   return declared.length ? [...new Set(declared)] : null;
 }
 
-// Only translate the public option names, not arbitrary effort-to-token ratios.
-// Omitting settings preserves the provider's model default. A level is checked
-// against the catalog's ladder when one is declared; otherwise the value is sent
-// as given (within the wire vocabulary) and the server decides, and an explicit
-// thinkingBudget is likewise passed through unvalidated beyond its wire type.
+// Gemini 2.5 models take thinkingBudget only (thinkingLevel is unsupported).
+// Documented ranges: 2.5 Pro 128–32768 (cannot disable), 2.5 Flash 0–24576,
+// 2.5 Flash-Lite 0 or 512–24576; -1 is dynamic thinking for all of them.
+function budgetSpec(model) {
+  const bare = String(model || '').replace(/^models\//i, '').toLowerCase();
+  if (!/^gemini-2\.5(?:-|$)/.test(bare)) return null;
+  if (/^gemini-2\.5-pro/.test(bare)) {
+    return { name: 'Gemini 2.5 Pro', min: 128, max: 32768, canDisable: false, efforts: { minimal: 128, low: 1024, medium: 8192, high: 32768 } };
+  }
+  if (/^gemini-2\.5-flash-lite/.test(bare)) {
+    return { name: 'Gemini 2.5 Flash-Lite', min: 512, max: 24576, canDisable: true, efforts: { minimal: 512, low: 1024, medium: 8192, high: 24576 } };
+  }
+  return { name: 'Gemini 2.5 Flash', min: 0, max: 24576, canDisable: true, efforts: { minimal: 0, low: 1024, medium: 8192, high: 24576 } };
+}
+
+// Levels documented for models whose ladder differs from the generic wire
+// vocabulary (a catalog ladder, when declared, still takes precedence).
+function documentedThinkingLevels(model) {
+  const bare = String(model || '').replace(/^models\//i, '').toLowerCase();
+  if (bare === 'gemini-4-argon' || bare === 'gemini-3.8-flash') return ['low', 'medium', 'high'];
+  return null;
+}
+
+function checkBudget(model, spec, budget) {
+  if (!Number.isInteger(budget) || budget < -1) {
+    throw new TypeError('thinkingBudget must be -1 (dynamic), 0, or a positive integer.');
+  }
+  if (!spec || budget === -1) return;
+  if (budget === 0 && !spec.canDisable) {
+    throw new TypeError(`${model} (${spec.name}) cannot disable thinking; thinkingBudget 0 is not allowed.`);
+  }
+  if (budget !== 0 && (budget < spec.min || budget > spec.max)) {
+    throw new TypeError(`${model} (${spec.name}) thinkingBudget must be -1, ${spec.canDisable ? '0, or ' : ''}${spec.min}–${spec.max}; received ${budget}.`);
+  }
+}
+
+// Only translate the public option names. Omitting settings preserves the
+// provider's model default. Gemini 2.5 models use thinkingBudget (a generic
+// effort maps to a budget; an explicit thinkingLevel is rejected locally and
+// budgets are range-checked). Other models use thinkingLevel, checked against
+// the catalog/documented ladder; unknown models pass values within the wire
+// vocabulary and the server decides.
 export function geminiThinkingConfig(model, opts = {}, { includeThoughts, provider = 'gemini' } = {}) {
   const rawBudget = opts.thinkingBudget ?? opts.thinkingBudgetTokens;
   const hasBudget = rawBudget !== undefined && rawBudget !== null && rawBudget !== '';
+  const spec = budgetSpec(model);
+  const explicitLevel = opts.thinkingLevel == null ? '' : String(opts.thinkingLevel).trim().toLowerCase();
   const rawLevel = opts.thinkingLevel ?? (hasBudget ? undefined : opts.effort);
   const level = rawLevel == null ? '' : String(rawLevel).trim().toLowerCase();
   const config = {};
@@ -31,8 +70,16 @@ export function geminiThinkingConfig(model, opts = {}, { includeThoughts, provid
   if (level && hasBudget) {
     throw new TypeError('Choose thinkingLevel/effort or thinkingBudget, not both.');
   }
-  if (level) {
-    const supported = catalogThinkingLevels(model, provider) ?? LEVELS;
+  if (spec && explicitLevel) {
+    throw new TypeError(`${model} (${spec.name}) does not support thinkingLevel; use thinkingBudget.`);
+  }
+  if (spec && level) {
+    if (!Object.hasOwn(spec.efforts, level)) {
+      throw new TypeError(`${model} supports thinking levels ${Object.keys(spec.efforts).join(', ')}; received ${level}.`);
+    }
+    config.thinkingBudget = spec.efforts[level];
+  } else if (level) {
+    const supported = catalogThinkingLevels(model, provider) ?? documentedThinkingLevels(model) ?? LEVELS;
     if (!supported.includes(level)) {
       throw new TypeError(`${model} supports thinking levels ${supported.join(', ')}; received ${level}.`);
     }
@@ -40,9 +87,7 @@ export function geminiThinkingConfig(model, opts = {}, { includeThoughts, provid
   }
   if (hasBudget) {
     const budget = Number(rawBudget);
-    if (!Number.isInteger(budget) || budget < -1) {
-      throw new TypeError('thinkingBudget must be -1 (dynamic), 0, or a positive integer.');
-    }
+    checkBudget(model, spec, budget);
     config.thinkingBudget = budget;
   }
   return Object.keys(config).length ? config : undefined;

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

@@ -17,7 +17,12 @@ import {
 } from '../stall-policy.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { GEMINI_FIRST_BYTE_TIMEOUT_MS, consumeGeminiRestStreamResponse } from './gemini-stream.mjs';
-import { applyGeminiErrorContract } from './gemini-error-contract.mjs';
+import {
+  applyGeminiErrorContract,
+  geminiContinuationUnsupportedError,
+  geminiFinishErrorFields,
+  geminiFinishReasonKind,
+} from './gemini-error-contract.mjs';
 import {
   GEMINI_MIDSTREAM_MAX_ATTEMPTS,
   geminiEndsWithFunctionResponse,
@@ -50,6 +55,7 @@ import {
 import {
   awaitSharedCreate,
   dropRejectedGeminiCache,
+  geminiBareModelId,
   geminiCacheCreateBody,
   geminiCacheEntry,
   geminiCachePrefixIdentity,
@@ -275,6 +281,10 @@ export class GeminiProvider {
     if (decision.canReuseState) {
       return state.cacheName;
     }
+    // A request forked from a shared prefix (/btw: opts.sharedCachePrefixCount)
+    // only reads the session's live cache. Creating or refreshing one would
+    // store the fork's own suffix (the appended reply and question).
+    if (opts.sharedCachePrefixCount) return decision.canAttachState ? state.cacheName : null;
     if (!apiKey || geminiExplicitCacheRefused(model)) return null;
     const { canAttachState } = decision;
     if (geminiPrefixBelowMinimum({ model, systemInstruction, geminiTools, contents, opts, currentIter })) {
@@ -584,10 +594,15 @@ export class GeminiProvider {
       cachedContent,
     });
     const parsed = parseGeminiCandidate(response, textLeakGuard);
-    emitGeminiToolCalls(parsed.nativeToolCalls, callbacks.onToolCall);
     const usage = resolveGeminiUsage(response, opts, cachedContent, useModel);
+    // Terminal status first: a failed candidate's calls are never dispatched.
     const incomplete = geminiIncompleteError(response, parsed, useModel, usage);
     if (incomplete) {
+      Object.assign(incomplete, geminiFinishErrorFields(response));
+      if (geminiFinishReasonKind(incomplete.finishReason) === 'continuation') {
+        // Direct Gemini only: surface the typed result with its token.
+        throw geminiContinuationUnsupportedError(incomplete, response);
+      }
       // A malformed / unexpected tool call that survived the stream ladder
       // (4 attempts) is spent; the loop must not multiply that budget.
       if (
@@ -599,6 +614,8 @@ export class GeminiProvider {
       }
       throw incomplete;
     }
+    textLeakGuard?.releaseDeferredToolCalls?.();
+    emitGeminiToolCalls(parsed.nativeToolCalls, callbacks.onToolCall);
     return geminiSendResult(parsed, useModel, opts, usage);
   }
 
@@ -626,7 +643,7 @@ export class GeminiProvider {
   }
 
   async _restGenerateContent(useModel, apiKey, body, fallbackSignal) {
-    const nonStreamUrl = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(useModel)}:generateContent?key=${encodeURIComponent(apiKey)}`;
+    const nonStreamUrl = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(geminiBareModelId(useModel))}:generateContent?key=${encodeURIComponent(apiKey)}`;
     const res = await this._fetch(nonStreamUrl, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
@@ -650,10 +667,10 @@ export class GeminiProvider {
   // { retryUncached: true } when the cache itself was rejected and the send
   // must be replayed without it.
   async _streamCachedViaRest(stream, internal) {
-    const { opts, signal, useModel, contents, generationConfig, cachedContent, callbacks } = stream;
+    const { opts, signal, useModel, contents, generationConfig, safetySettings, cachedContent, callbacks } = stream;
     const apiKey = this._getApiKey();
-    const genUrl = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(useModel)}:streamGenerateContent?alt=sse&key=${encodeURIComponent(apiKey)}`;
-    const body = geminiCachedRestBody({ opts, contents, cachedContent, generationConfig });
+    const genUrl = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(geminiBareModelId(useModel))}:streamGenerateContent?alt=sse&key=${encodeURIComponent(apiKey)}`;
+    const body = geminiCachedRestBody({ opts, contents, cachedContent, generationConfig, safetySettings });
     // cachedContent owns tools + toolConfig. The API rejects a
     // generateContent request that repeats either field.
     // Option A (mirror anthropic-oauth): no absolute wall-clock cap on a
@@ -679,7 +696,6 @@ export class GeminiProvider {
           connected();
           const textLeakGuard = geminiTextLeakGuardFor(stream);
           const response = await consumeGeminiRestStreamResponse(res, {
-            acceptEmptyNoFinish: afterToolResult,
             signal: attemptSignal,
             onStreamDelta: callbacks.onStreamDelta,
             onTextDelta: callbacks.onTextDelta,
@@ -715,13 +731,15 @@ export class GeminiProvider {
   }
 
   async _streamViaSdk(stream) {
-    const { opts, signal, useModel, systemInstruction, geminiTools, toolConfig, generationConfig, contents } = stream;
+    const { opts, signal, useModel, systemInstruction, geminiTools, toolConfig, generationConfig, safetySettings, contents } =
+      stream;
     const genModel = this._currentGenAI().getGenerativeModel({
       model: useModel,
       systemInstruction,
       tools: geminiTools,
       ...(toolConfig ? { toolConfig } : {}),
       ...(generationConfig ? { generationConfig } : {}),
+      ...(safetySettings ? { safetySettings } : {}),
     });
     // Option A (mirror anthropic-oauth): pure pass-through of the external
     // signal, no absolute streaming total cap. See the REST path.

package/src/runtime/agent/orchestrator/providers/grok-client-version.mjs

@@ -3,7 +3,7 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // Grok CLI client version for the cli-chat-proxy version gate (HTTP 426).
 // Effective = env override, else max(floor, learned-from-426, live npm latest
 // of the official @xai-official/grok CLI).
-export const GROK_CLI_VERSION_FLOOR = '1.0.52';
+export const GROK_CLI_VERSION_FLOOR = '1.0.60';
 export const GROK_CLI_NPM_PACKAGE = '@xai-official/grok';
 
 const live = createNpmVersionSource(GROK_CLI_NPM_PACKAGE, { persistKey: 'grok-cli' });

package/src/runtime/agent/orchestrator/providers/grok-oauth.mjs

@@ -412,6 +412,7 @@ export class GrokOAuthProvider {
       apiKey: token,
       baseURL: PROXY_BASE_URL,
       responsesTransport: resolveGrokOAuthResponsesTransport(),
+      transportPinned: true,
       extraHeaders: requestHeaders,
     });
     this._innerKey = key;

package/src/runtime/agent/orchestrator/providers/lib/action-input-contract.mjs

@@ -1,3 +1,5 @@
+import { mergeFlatSchemaProperty } from './flat-schema-merge.mjs';
+
 // Preserve action-specific input rules when a provider needs a flat schema.
 // Field definitions remain shared; only the per-action field names and differing
 // enums/bounds are repeated, rather than copying every full schema branch.
@@ -34,3 +36,61 @@ export function actionInputContract(schema) {
   });
   return `Allowed input by action (* required): ${rows.join('; ')}.`;
 }
+
+// A per-action input union: the root's `action` enum and an `input` whose
+// anyOf alternatives are object schemas, each titled with the one action it
+// belongs to. Returns those alternatives as action/input branches, or null.
+function actionInputBranches(schema) {
+  const actions = schema?.properties?.action?.enum;
+  const alternatives = schema?.properties?.input?.anyOf;
+  if (!Array.isArray(actions) || !Array.isArray(alternatives) || !alternatives.length) return null;
+  const branches = alternatives.map((alternative) =>
+    alternative?.properties && actions.includes(alternative.title)
+      ? { properties: { action: { enum: [alternative.title] }, input: alternative } }
+      : null
+  );
+  return branches.every(Boolean) ? branches : null;
+}
+
+/** The flat projection of a per-action input union: `input` becomes the
+ *  merged field set of every alternative, its description listing the fields
+ *  per action. Any other schema is returned as is; the input is never mutated. */
+export function flattenActionInputUnion(schema) {
+  const branches = actionInputBranches(schema);
+  if (!branches) return schema;
+  const { anyOf: _anyOf, description, ...base } = schema.properties.input;
+  const merged = branches
+    .map(({ properties }) => {
+      const { title: _title, description: _description, ...shape } = properties.input;
+      return shape;
+    })
+    .reduce((current, shape) => mergeFlatSchemaProperty(current, shape));
+  const contract = actionInputContract({ oneOf: branches });
+  return {
+    ...schema,
+    properties: {
+      ...schema.properties,
+      input: { ...base, ...merged, description: [description, contract].filter(Boolean).join(' ') },
+    },
+  };
+}
+
+// Nested per-action input unions keyed by their flat projection's JSON. A tool
+// advertises the flat projection on every path; only provider paths verified
+// to accept nested alternatives opt in through actionInputUnionFor. Keyed by
+// content, so a request snapshot's clone still resolves.
+const nestedByFlat = new Map();
+
+/** Register `nested` (a per-action input union) and return the flat
+ *  projection the tool advertises. */
+export function advertiseActionInputUnion(nested) {
+  const flat = flattenActionInputUnion(nested);
+  nestedByFlat.set(JSON.stringify(flat), nested);
+  return flat;
+}
+
+/** The registered nested union for an advertised flat schema, else `schema`. */
+export function actionInputUnionFor(schema) {
+  if (!schema?.properties?.action || !schema.properties.input) return schema;
+  return nestedByFlat.get(JSON.stringify(schema)) ?? schema;
+}

package/src/runtime/agent/orchestrator/providers/lib/anthropic-native-blocks.mjs

@@ -19,6 +19,7 @@ export const NATIVE_SERVER_TOOL_RESULT_BLOCK_TYPES = new Set([
   'bash_code_execution_tool_result',
   'text_editor_code_execution_tool_result',
   'mcp_tool_result',
+  'tool_search_tool_result',
 ]);
 
 export function isNativeServerToolBlockType(type) {