mixdog 1.2.2 → 1.2.3

package/src/runtime/agent/orchestrator/providers/gemini-request-body.mjs

@@ -12,6 +12,30 @@ import { geminiThinkingConfig } from './gemini-thinking.mjs';
 import { toGeminiContents, toGeminiRequestTools, toGeminiToolConfig } from './gemini-schema.mjs';
 
 // Request pieces shared by the cached REST path and the SDK path.
+// Caller-supplied generation controls the wire carries in generationConfig.
+// maxOutputTokens counts thought tokens too (see the thinking docs). Anything
+// invalid is rejected here instead of being dropped. (safetySettings is a
+// request-level field, forwarded separately.)
+function geminiGenerationControls(opts) {
+  const controls = {};
+  const maxRaw = opts.maxOutputTokens ?? opts.max_output_tokens;
+  if (maxRaw !== undefined && maxRaw !== null) {
+    const max = Number(maxRaw);
+    if (!Number.isInteger(max) || max <= 0) {
+      throw new TypeError('maxOutputTokens must be a positive integer (it includes thinking tokens).');
+    }
+    controls.maxOutputTokens = max;
+  }
+  if (opts.temperature !== undefined && opts.temperature !== null) {
+    const temperature = Number(opts.temperature);
+    if (!Number.isFinite(temperature) || temperature < 0 || temperature > 2) {
+      throw new TypeError('temperature must be a number between 0 and 2.');
+    }
+    controls.temperature = temperature;
+  }
+  return controls;
+}
+
 export function buildGeminiRequest(messages, useModel, tools, opts) {
   // Gemini returns thought summaries only when the request asks for them.
   // Without this the reasoning channel stays empty for the whole turn and
@@ -19,7 +43,11 @@ export function buildGeminiRequest(messages, useModel, tools, opts) {
   // round reads as another preamble. On by default for every model; an
   // explicit opts.includeThoughts still wins.
   const thinkingConfig = geminiThinkingConfig(useModel, opts, { includeThoughts: true });
-  const generationConfig = thinkingConfig ? { thinkingConfig } : undefined;
+  const controls = geminiGenerationControls(opts);
+  const generationConfig =
+    thinkingConfig || Object.keys(controls).length
+      ? { ...(thinkingConfig ? { thinkingConfig } : {}), ...controls }
+      : undefined;
   const systemInstruction =
     messages
       .filter((m) => m.role === 'system')
@@ -29,17 +57,24 @@ export function buildGeminiRequest(messages, useModel, tools, opts) {
   const contents = toGeminiContents(chatMsgs, useModel);
   if (!contents.length) throw new Error('No messages to send');
 
-  const requestTools = toGeminiRequestTools(tools, opts.nativeTools);
+  const requestTools = toGeminiRequestTools(tools, opts.nativeTools, { onToolExcluded: opts.onToolExcluded });
   const geminiTools = requestTools.length ? requestTools : undefined;
-  const toolConfig = tools?.length ? toGeminiToolConfig(opts.toolChoice) : undefined;
-  return { generationConfig, systemInstruction, contents, geminiTools, toolConfig };
+  // Tool config only accompanies function declarations that were kept.
+  const toolConfig = requestTools.some((entry) => entry.functionDeclarations?.length)
+    ? toGeminiToolConfig(opts.toolChoice)
+    : undefined;
+  if (opts.safetySettings !== undefined && opts.safetySettings !== null && !Array.isArray(opts.safetySettings)) {
+    throw new TypeError('safetySettings must be an array of { category, threshold } entries.');
+  }
+  const safetySettings = opts.safetySettings?.length ? opts.safetySettings : undefined;
+  return { generationConfig, systemInstruction, contents, geminiTools, toolConfig, safetySettings };
 }
 
 // The generateContent body for a cached prefix. The cache carries the
 // recorded prefix; every uncached tail turn is sent, not just the last
 // message, so reused cachedContents preserve full conversation context
 // between periodic refreshes.
-export function geminiCachedRestBody({ opts, contents, cachedContent, generationConfig }) {
+export function geminiCachedRestBody({ opts, contents, cachedContent, generationConfig, safetySettings }) {
   const cachedPrefixContentCount = Number.isFinite(Number(opts.providerState?.gemini?.cachePrefixContentCount))
     ? Math.max(0, Math.min(contents.length, Math.trunc(Number(opts.providerState.gemini.cachePrefixContentCount))))
     : 0;
@@ -48,5 +83,6 @@ export function geminiCachedRestBody({ opts, contents, cachedContent, generation
     contents: deltaContents.length ? deltaContents : contents.slice(-1),
     cachedContent,
     ...(generationConfig ? { generationConfig } : {}),
+    ...(safetySettings ? { safetySettings } : {}),
   };
 }

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

@@ -11,8 +11,9 @@
  *                     re-issues the whole request up to 4 attempts total at
  *                     1s / 2s / 4s. A response that finished with no finish
  *                     reason is never judged here, and right after a tool
- *                     result an empty response (no finish reason or no text)
- *                     is accepted as the model's answer. An empty answer that
+ *                     result an empty STOP answer is accepted as the model's
+ *                     answer (an empty stream with no finish reason is still
+ *                     unfinished). An empty answer that
  *                     survives all 4 attempts throws a typed, provider-terminal
  *                     invalid-stream error instead of returning nothing.
  *   long advice       a server wait over 300s ends recovery on both phases
@@ -25,6 +26,7 @@
 import { readStreamOutcome } from './lib/stream-outcome.mjs';
 import { DETERMINISTIC_KINDS, providerErrorKind, typedCodeKind } from './provider-error-kind.mjs';
 import { midstreamRetryDelayMs } from './retry-backoff.mjs';
+import { geminiFinishReasonKind, geminiNormalizeFinishReason } from './gemini-error-contract.mjs';
 import { classifyError, markProviderRecoveryExhausted, sleepWithAbort, withRetry } from './retry-classifier.mjs';
 
 export const GEMINI_REQUEST_RETRY = Object.freeze({
@@ -80,16 +82,13 @@ export function geminiMidstreamDelayMs(err, streamAttempt, signal = null) {
 
 const statusOf = (err) => Number(err?.httpStatus || err?.status || 0);
 
-const INVALID_TOOL_CALL_FINISH = new Set(['MALFORMED_FUNCTION_CALL', 'UNEXPECTED_TOOL_CALL']);
-// Empty-text finishes that are deterministic refusals or output-limit stops,
-// owned by the policy / incomplete handling instead of a re-ask.
-const EMPTY_TEXT_TERMINAL_FINISH = new Set(['MAX_TOKENS', 'SAFETY', 'RECITATION']);
-
 /**
  * Invalid stream: the reason a finished response is unusable
- * ('MALFORMED_FUNCTION_CALL' | 'UNEXPECTED_TOOL_CALL' | 'NO_RESPONSE_TEXT'),
- * or null. A response that carried a tool call, or whose text was already
- * relayed, is never invalid (and never replayed).
+ * ('MALFORMED_FUNCTION_CALL' | 'UNEXPECTED_TOOL_CALL' | 'MALFORMED_RESPONSE' |
+ * 'NO_RESPONSE_TEXT'), or null. A response that carried a tool call, or whose
+ * text was already relayed, is never invalid (and never replayed). Only a
+ * STOP with no text is "no text"; every other documented finish (policy,
+ * output limit, continuation, OTHER, ...) is owned by the incomplete handling.
  */
 export function geminiInvalidStreamReason(response, textLeakGuard = null, { afterToolResult = false } = {}) {
   const candidate = response?.candidates?.[0];
@@ -97,9 +96,10 @@ export function geminiInvalidStreamReason(response, textLeakGuard = null, { afte
   if (parts.some((part) => part?.functionCall)) return null;
   if ((textLeakGuard?.getLeakedToolCalls?.() || []).length > 0) return null;
   if ((textLeakGuard?.getRelayedText?.() || '').length > 0) return null;
-  const finish = String(candidate?.finishReason || '').replace(/^FINISH_REASON_/, '');
-  if (INVALID_TOOL_CALL_FINISH.has(finish)) return finish;
-  if (!finish || EMPTY_TEXT_TERMINAL_FINISH.has(finish)) return null;
+  const finish = geminiNormalizeFinishReason(candidate?.finishReason);
+  const kind = geminiFinishReasonKind(finish);
+  if (kind === 'invalid_tool_call') return finish;
+  if (kind !== 'complete') return null;
   // Right after a tool result the model may legitimately answer with nothing.
   if (afterToolResult) return null;
   const text = parts

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

@@ -5,8 +5,21 @@
  */
 import { SchemaType } from '@google/generative-ai';
 import { traceHash, stableTraceStringify } from './trace-utils.mjs';
-import { normalizeContentForGeminiParts, splitToolContentForGemini } from './media-normalization.mjs';
+import {
+  normalizeContentForGeminiParts,
+  splitToolContentForGemini,
+  geminiPartMetadata,
+} from './media-normalization.mjs';
 import { providerReplayItems } from './lib/provider-replay.mjs';
+import {
+  claudeBridgeInputSchema,
+  escapePointer,
+  geminiJsonSchemaProblem,
+  repairedToolInputSchema,
+  reportInvalidTool,
+} from './lib/claude-bridge-schema.mjs';
+import { actionInputUnionFor } from './lib/action-input-contract.mjs';
+import { isGeminiFamilyModel } from './gemini-family.mjs';
 import { ensureGeminiToolCallSignatures } from './gemini-history-signatures.mjs';
 
 // Bounds on persisted provider metadata replayed back into the prompt.
@@ -20,14 +33,22 @@ function explicitGeminiMediaPart(part) {
   if (typeof inline?.data === 'string' && inline.data) {
     const mimeType = inline.mimeType || inline.mime_type || inline.mediaType || inline.media_type;
     if (typeof mimeType === 'string' && mimeType) {
-      return { inlineData: { mimeType, data: inline.data } };
+      return { inlineData: { mimeType, data: inline.data }, ...geminiPartMetadata(part) };
     }
   }
+  // An explicit fileData part keeps exactly the MIME type it declared; with
+  // none, the shared normalizer resolves it from the URI or omits it.
   const file = part.fileData || part.file_data;
   const fileUri = file?.fileUri || file?.file_uri;
   const mimeType = file?.mimeType || file?.mime_type || file?.mediaType || file?.media_type;
-  if (typeof fileUri === 'string' && fileUri && typeof mimeType === 'string' && mimeType) {
-    return { fileData: { mimeType, fileUri } };
+  if (typeof fileUri === 'string' && fileUri) {
+    const info = { fileUri };
+    if (typeof mimeType === 'string' && mimeType) info.mimeType = mimeType;
+    else {
+      const resolved = normalizeContentForGeminiParts([part])[0]?.fileData?.mimeType;
+      if (resolved) info.mimeType = resolved;
+    }
+    return { fileData: info, ...geminiPartMetadata(part) };
   }
   return null;
 }
@@ -506,34 +527,256 @@ function pruneTypeSpecificKeywords(result, rawType) {
 function needsJsonParameters(schema) {
   if (typeof schema === 'boolean') return true;
   if (!schema || typeof schema !== 'object') return false;
-  // The legacy dialect has no reference vocabulary; preserve both pointers
-  // and their definitions together, including recursive MCP contracts.
-  if (['$ref', '$defs', 'definitions'].some((key) => Object.hasOwn(schema, key))) return true;
-  const constraints = Object.keys(schema).filter(
-    (key) => !['description', 'title', 'default', 'examples', '$comment'].includes(key)
-  );
-  if (!constraints.length || (schema.type === 'array' && !schema.items)) return true;
+  return !legacyRepresentable(schema, true);
+}
+
+const LEGACY_JSON_TYPES = new Set(['string', 'number', 'integer', 'boolean', 'array', 'object']);
+// Annotation-only keywords: dropping them never widens the accepted arguments.
+const ANNOTATION_KEYS = new Set(['$schema', '$id', '$comment', 'examples']);
+const NON_CONSTRAINT_KEYS = new Set([...ANNOTATION_KEYS, 'description', 'title', 'default', 'example']);
+
+/** True when the legacy OpenAPI Schema subset expresses `input` exactly:
+ *  convertSchema would neither drop a constraint nor invent a replacement. */
+function legacyRepresentable(input, root = false) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return false;
+  const flat = flattenAllOf(input);
+  if (flat.conflict) return false;
+  const schema = flat.schema;
+  const keys = Object.keys(schema);
+  if (!keys.some((key) => !NON_CONSTRAINT_KEYS.has(key))) return false;
+  for (const key of keys) {
+    if (GEMINI_SCHEMA_FIELDS.has(key) || ANNOTATION_KEYS.has(key)) continue;
+    // additionalProperties:true is the default; anything else is a constraint.
+    if (key === 'additionalProperties' && schema[key] === true) continue;
+    return false;
+  }
+  if (schema.oneOf !== undefined || schema.not !== undefined) return false;
+
+  const declared = [].concat(schema.type ?? []);
+  const nonNull = declared.filter((type) => type !== 'null');
+  if (declared.length && !nonNull.length) return false;
+  if (nonNull.length > 1 || nonNull.some((type) => !LEGACY_JSON_TYPES.has(type))) return false;
+  let type = nonNull[0];
+  if (!type && (schema.properties || schema.required)) type = 'object';
+  if (!type && schema.items) type = 'array';
+
+  if (schema.enum !== undefined && (!Array.isArray(schema.enum) || schema.enum.some((v) => typeof v !== 'string'))) {
+    return false;
+  }
+  if (schema.const !== undefined && typeof schema.const !== 'string') return false;
+  if (['integer', 'number', 'boolean'].includes(type) && (schema.enum !== undefined || schema.const !== undefined)) {
+    return false;
+  }
+  if (!type && [...ALL_TYPE_SPECIFIC_KEYWORDS].some((key) => schema[key] !== undefined)) return false;
+
+  const lower = rawBound(schema, 'lower');
+  const upper = rawBound(schema, 'upper');
+  if ((lower?.exclusive || upper?.exclusive) && type !== 'integer') return false;
+  if (lower && upper && lower.value > upper.value) return false;
+  for (const [minKey, maxKey] of [
+    ['minLength', 'maxLength'],
+    ['minItems', 'maxItems'],
+    ['minProperties', 'maxProperties'],
+  ]) {
+    if (Number.isFinite(schema[minKey]) && Number.isFinite(schema[maxKey]) && schema[minKey] > schema[maxKey]) {
+      return false;
+    }
+  }
+
+  if (type === 'array') {
+    if (!schema.items || typeof schema.items !== 'object' || Array.isArray(schema.items)) return false;
+    if (!legacyRepresentable(schema.items)) return false;
+  }
+  if (type === 'object') {
+    const props = schema.properties;
+    if (props !== undefined && (!props || typeof props !== 'object' || Array.isArray(props))) return false;
+    const names = Object.keys(props || {});
+    // A free-form object has no legacy form (empty `properties` is rejected);
+    // only the root of a no-argument tool may be empty.
+    if (!names.length && !root && !Array.isArray(schema.anyOf)) return false;
+    if (schema.required !== undefined) {
+      if (!Array.isArray(schema.required)) return false;
+      if (schema.required.some((name) => typeof name !== 'string' || !names.includes(name))) return false;
+    }
+    if (!names.every((name) => legacyRepresentable(props[name]))) return false;
+  }
+  if (schema.anyOf !== undefined) {
+    if (!Array.isArray(schema.anyOf) || !schema.anyOf.every((branch) => legacyRepresentable(branch))) return false;
+  }
+  return true;
+}
+
+// Keywords the Gemini endpoints reject or ignore on parametersJsonSchema:
+// vendor extensions (`x-*`) and annotation-only keywords. None of them
+// constrains the accepted arguments, so dropping them keeps the semantics.
+const NON_STANDARD_SCHEMA_KEYS = new Set(['$schema', '$comment', 'deprecated', 'examples']);
+const isNonStandardSchemaKey = (key) => NON_STANDARD_SCHEMA_KEYS.has(key) || key.startsWith('x-');
+// Keys whose value maps names to subschemas (names are data, never stripped),
+// a single subschema, or a list of subschemas.
+const JSON_SCHEMA_MAP_KEYS = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas'];
+const JSON_SCHEMA_NODE_KEYS = [
+  'items',
+  'additionalItems',
+  'additionalProperties',
+  'unevaluatedItems',
+  'unevaluatedProperties',
+  'contains',
+  'propertyNames',
+  'not',
+  'if',
+  'then',
+  'else',
+];
+const JSON_SCHEMA_LIST_KEYS = ['prefixItems', 'allOf', 'anyOf', 'oneOf'];
+
+function stripNonStandardSchemaKeys(schema) {
+  if (Array.isArray(schema)) return schema.map(stripNonStandardSchemaKeys);
+  if (!schema || typeof schema !== 'object') return schema;
+  const out = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (isNonStandardSchemaKey(key)) continue;
+    if (JSON_SCHEMA_MAP_KEYS.includes(key) && value && typeof value === 'object' && !Array.isArray(value)) {
+      const children = {};
+      for (const [name, child] of Object.entries(value)) {
+        defineSchemaProperty(children, name, stripNonStandardSchemaKeys(child));
+      }
+      out[key] = children;
+    } else if (JSON_SCHEMA_NODE_KEYS.includes(key) || JSON_SCHEMA_LIST_KEYS.includes(key)) {
+      out[key] = stripNonStandardSchemaKeys(value);
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+const LEGACY_SCHEMA_TYPES = new Set(Object.values(SchemaType));
+
+/** Why a legacy `parameters` Schema (the OpenAPI subset convertSchema targets)
+ *  is rejected by Gemini, as `{ pointer, reason }`, or null when it is valid:
+ *  an OBJECT root (or none), known types, an `items` schema on every ARRAY,
+ *  string enums, and `required` names that exist in `properties`. */
+function legacyParametersProblem(node, pointer = '', root = true) {
+  const bad = (reason, at = pointer) => ({ pointer: at, reason });
+  if (!node || typeof node !== 'object' || Array.isArray(node)) return bad('a Gemini Schema must be an object');
+  const { type, properties, required, items, anyOf } = node;
+  if (type !== undefined && !LEGACY_SCHEMA_TYPES.has(type))
+    return bad(`unsupported type ${JSON.stringify(type)}`, `${pointer}/type`);
+  if (root && type !== undefined && type !== SchemaType.OBJECT)
+    return bad('the input schema root must have type "object"', `${pointer}/type`);
+  if (node.enum !== undefined && (!Array.isArray(node.enum) || node.enum.some((value) => typeof value !== 'string'))) {
+    return bad('enum must be an array of strings', `${pointer}/enum`);
+  }
+  if (type === SchemaType.ARRAY && (!items || typeof items !== 'object' || Array.isArray(items))) {
+    return bad('an array schema needs an "items" schema', `${pointer}/items`);
+  }
+  // A node without its own `properties` (an anyOf branch narrowing the
+  // parent's required keys) has nothing to check `required` against.
+  if (required !== undefined) {
+    const names = properties && typeof properties === 'object' ? Object.keys(properties) : null;
+    if (!Array.isArray(required) || (names && required.some((name) => !names.includes(name)))) {
+      return bad('required must list properties declared in "properties"', `${pointer}/required`);
+    }
+  }
   const children = [
-    ...Object.values(schema.properties || {}),
-    ...(schema.items ? [schema.items] : []),
-    ...(typeof schema.additionalProperties === 'object' ? [schema.additionalProperties] : []),
-    ...(schema.anyOf || []),
-    ...(schema.oneOf || []),
-    ...(schema.allOf || []),
+    ...Object.entries(properties || {}).map(([name, child]) => [child, `${pointer}/properties/${escapePointer(name)}`]),
+    ...(items ? [[items, `${pointer}/items`]] : []),
+    ...(Array.isArray(anyOf) ? anyOf.map((child, i) => [child, `${pointer}/anyOf/${i}`]) : []),
   ];
-  return children.some(needsJsonParameters);
+  for (const [child, at] of children) {
+    const problem = legacyParametersProblem(child, at, false);
+    if (problem) return problem;
+  }
+  return null;
 }
 
-export function toGeminiTools(tools) {
-  return {
-    functionDeclarations: tools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      ...(needsJsonParameters(t.inputSchema)
-        ? { parametersJsonSchema: structuredClone(t.inputSchema) }
-        : { parameters: convertSchema(t.inputSchema) }),
-    })),
-  };
+/** Why the declaration's schema (`parameters` or `parametersJsonSchema`) is
+ *  rejected by Gemini, or null. A tool without a schema is sent as written. */
+function geminiDeclarationProblem(declaration) {
+  if (declaration.parametersJsonSchema !== undefined) return geminiJsonSchemaProblem(declaration.parametersJsonSchema);
+  return declaration.parameters === undefined ? null : legacyParametersProblem(declaration.parameters);
+}
+
+// `claudeBridge: true` (Claude models behind Antigravity) always encodes the
+// schema as `parametersJsonSchema`: the bridge hands it to Anthropic as a
+// draft 2020-12 input_schema, and the legacy `parameters` projection
+// (convertSchema) rewrites type arrays, numeric enums and nullable unions.
+// A tool whose schema is invalid for Anthropic is left out and reported
+// (`onToolExcluded`, default console.warn); the other tools are unaffected.
+// Gemini routes validate each final declaration the same way; `validate:
+// false` (an Antigravity model outside the Gemini family) converts without it.
+export function toGeminiTools(tools, { claudeBridge = false, onToolExcluded, validate = true } = {}) {
+  const functionDeclarations = [];
+  tools.forEach((t, index) => {
+    const declaration = { name: t.name, description: t.description };
+    if (claudeBridge) {
+      // The bridge accepts nested per-action input alternatives.
+      const result = claudeBridgeInputSchema(actionInputUnionFor(t.inputSchema));
+      if (!result.schema) {
+        reportInvalidTool(t.name, index, result, onToolExcluded);
+        return;
+      }
+      declaration.parametersJsonSchema = result.schema;
+    } else if (validate) {
+      const accepted = acceptedGeminiTool(t, index, onToolExcluded);
+      if (!accepted) return;
+      Object.assign(declaration, accepted.fields);
+    } else {
+      Object.assign(declaration, geminiSchemaFields(t.inputSchema));
+    }
+    functionDeclarations.push(declaration);
+  });
+  return { functionDeclarations };
+}
+
+function geminiSchemaFields(inputSchema) {
+  if (needsJsonParameters(inputSchema)) {
+    return { parametersJsonSchema: stripNonStandardSchemaKeys(structuredClone(inputSchema)) };
+  }
+  return { parameters: convertSchema(inputSchema) };
+}
+
+// A Gemini endpoint rejects the whole request for one bad declaration. A
+// declaration it would reject is first rebuilt from the lowered schema
+// (draft-07/04 constructs); one still rejected is reported and left out.
+// Returns { tool, fields } (the tool to send, its schema fields) or null.
+function acceptedGeminiTool(tool, index, onToolExcluded) {
+  const fields = geminiSchemaFields(tool.inputSchema);
+  let problem = geminiDeclarationProblem(fields);
+  if (!problem) return { tool, fields };
+  const repaired = repairedToolInputSchema(tool.inputSchema, 'gemini');
+  if (repaired) {
+    const repairedFields = geminiSchemaFields(repaired);
+    problem = geminiDeclarationProblem(repairedFields);
+    if (!problem) return { tool: { ...tool, inputSchema: repaired }, fields: repairedFields };
+  }
+  reportInvalidTool(tool.name, index, problem, onToolExcluded, '[gemini] tool');
+  return null;
+}
+
+/** The tools whose schema a Gemini-family model behind an OpenAI-compatible
+ *  route (OpenRouter, a gateway) accepts, in order: unchanged, or carrying
+ *  the lowered schema when only that is accepted. The others are reported
+ *  through `onToolExcluded`. */
+export function geminiAcceptedTools(tools, onToolExcluded) {
+  let changed = false;
+  const out = [];
+  tools.forEach((tool, index) => {
+    const accepted = acceptedGeminiTool(tool, index, onToolExcluded);
+    if (accepted?.tool !== tool) changed = true;
+    if (accepted) out.push(accepted.tool);
+  });
+  return changed ? out : tools;
+}
+
+/** The `{ name, pointer, reason }` for which a Gemini route leaves `tool`
+ *  out of its requests, or null when the tool is sent. Reports nothing. */
+export function geminiToolExclusion(tool) {
+  let exclusion = null;
+  geminiAcceptedTools([tool], (found) => {
+    exclusion = found;
+  });
+  return exclusion;
 }
 
 export function toGeminiNativeTools(nativeTools) {
@@ -552,8 +795,10 @@ export function toGeminiNativeTools(nativeTools) {
 
 // The request `tools` array: hosted tools first, then one function-declaration
 // entry when function tools are present. Empty when neither is present.
-export function toGeminiRequestTools(tools, nativeTools) {
-  const functionTools = tools?.length ? [toGeminiTools(tools)] : [];
+export function toGeminiRequestTools(tools, nativeTools, options) {
+  const declarations = tools?.length ? toGeminiTools(tools, options) : null;
+  // Every function tool may have been left out as invalid for the provider.
+  const functionTools = declarations?.functionDeclarations.length ? [declarations] : [];
   return [...toGeminiNativeTools(nativeTools), ...functionTools];
 }
 
@@ -607,18 +852,62 @@ export function toGeminiToolConfig(toolChoice) {
 // One tool result: its functionResponse part, plus any media it carried as
 // ordinary content parts. The ids pair a call with its response (the Claude
 // models behind Antigravity require them) and are harmless for Gemini.
-function toGeminiToolResult(message, toolNameByCallId) {
+// Multimodal function responses (FunctionResponse.parts) exist on Gemini 3+.
+// Older Gemini ids and other families (Claude behind Antigravity) keep media
+// as sibling parts of the response turn.
+function supportsFunctionResponseParts(model) {
+  if (!isGeminiFamilyModel(model)) return false;
+  const major = /gemini-(\d+)/i.exec(String(model))?.[1];
+  return major === undefined || Number(major) >= 3;
+}
+
+// FunctionResponsePart carries only inlineData{mimeType,data}; anything else
+// (fileData URIs, parts with mediaResolution/videoMetadata) stays a sibling.
+const isNestableMedia = (part) =>
+  part?.inlineData && Object.keys(part).length === 1 && Object.keys(part.inlineData).length === 2;
+
+// A failed result travels under `error`, the key Gemini's function-calling
+// contract reserves for failures; a successful one keeps `result`.
+const isFailedToolResult = (message) => message.toolKind === 'error' || message.isError === true;
+
+// `callsByFinalId` maps a tool result's id to the functionCall the request
+// replays for it. The response must name exactly the id that call carries:
+// the id the transcript settled on (possibly renamed `-2`) can differ from the
+// recorded part, and a recorded Gemini part may carry no id at all, in which
+// case the response carries none either. An unmatched result keeps its own id.
+function toGeminiToolResult(message, toolNameByCallId, nestMedia, callsByFinalId) {
   const functionName = toolNameByCallId?.get(message.toolCallId) || message.toolCallId || '';
-  const { response, mediaParts } = splitGeminiToolContent(message.content);
+  const { response: rawResponse, mediaParts } = splitGeminiToolContent(message.content);
+  const response = isFailedToolResult(message) && 'result' in rawResponse ? { error: rawResponse.result } : rawResponse;
   const functionResponse = { name: functionName, response };
-  if (typeof message.toolCallId === 'string' && message.toolCallId) functionResponse.id = message.toolCallId;
-  return { functionResponsePart: { functionResponse }, mediaParts };
+  const replayedCall = callsByFinalId?.get(message.toolCallId);
+  const responseId = replayedCall ? replayedCall.id : message.toolCallId;
+  if (typeof responseId === 'string' && responseId) functionResponse.id = responseId;
+  if (!nestMedia) return { functionResponsePart: { functionResponse }, mediaParts };
+  const nested = mediaParts.filter(isNestableMedia);
+  if (nested.length) functionResponse.parts = nested;
+  return {
+    functionResponsePart: { functionResponse },
+    mediaParts: mediaParts.filter((part) => !isNestableMedia(part)),
+  };
+}
+
+// A replay recorded by a non-Gemini model (Claude behind Antigravity) carries
+// signatures Gemini rejects: its replay envelope and the signed metadata
+// derived from the same response must not reach a Gemini request.
+function hasForeignReplay(message) {
+  const replay = message?.providerReplay;
+  if (replay?.provider !== 'gemini' && replay?.provider !== 'antigravity') return false;
+  const recorded = replay.requestContext?.model;
+  return typeof recorded === 'string' && recorded !== '' && !isGeminiFamilyModel(recorded);
 }
 
 function toGeminiContent(message) {
   if (!message || message.role === 'system') return null;
+  const foreign = message.role === 'assistant' && hasForeignReplay(message);
+  if (foreign) message = { ...message, providerMetadata: undefined };
   const orderedReplay =
-    message.role === 'assistant' ? providerReplayItems(message, ['gemini', 'antigravity']) : undefined;
+    message.role === 'assistant' && !foreign ? providerReplayItems(message, ['gemini', 'antigravity']) : undefined;
   if (orderedReplay?.length) {
     return { role: 'model', parts: orderedReplay };
   }
@@ -641,6 +930,7 @@ function toGeminiContent(message) {
         },
       };
       if (
+        !foreign &&
         typeof tc.thoughtSignature === 'string' &&
         tc.thoughtSignature &&
         tc.thoughtSignature.length <= MAX_THOUGHT_SIGNATURE_CHARS
@@ -716,20 +1006,48 @@ export function toGeminiContents(messages, model = '', { repairToolSignatures =
   // Map synthetic toolCallId -> function name from prior assistant
   // tool_calls so each functionResponse part carries the real function name.
   const toolNameByCallId = new Map();
+  // Final call id -> the functionCall the request replays for it. Replayed
+  // assistant turns are the raw recorded parts, so a generated or renamed id
+  // never appears on them. Claude/GPT-OSS routes need the pair to share the
+  // final id, so it is stamped on the part; a Gemini part keeps exactly what
+  // the server sent (possibly no id) and the response follows it.
+  const callsByFinalId = new Map();
+  const assistantContent = new Map();
+  const stampFinalIds = !!model && !isGeminiFamilyModel(model);
   for (const m of messages) {
     if (m?.role === 'assistant' && Array.isArray(m.toolCalls)) {
       for (const tc of m.toolCalls) {
         if (tc?.id && tc?.name) toolNameByCallId.set(tc.id, tc.name);
       }
+      const content = toGeminiContent(m);
+      assistantContent.set(m, content);
+      const replayed = (content?.parts || []).filter((part) => part?.functionCall);
+      m.toolCalls.forEach((tc, index) => {
+        if (!tc?.id) return;
+        // Positional when the turn replays one call per tool call (the id may
+        // be renamed, and a bridged call_tool keeps its wire name and id);
+        // otherwise only a part already carrying the id can be matched.
+        const part =
+          replayed.length === m.toolCalls.length ? replayed[index] : replayed.find((p) => p.functionCall.id === tc.id);
+        if (!part) return;
+        if (stampFinalIds) part.functionCall.id = tc.id;
+        callsByFinalId.set(tc.id, part.functionCall);
+      });
     }
   }
   // Consecutive tool results share one user turn: every functionResponse part
   // first (one per call, in call order), then the media the results carried as
   // sibling inlineData/fileData parts.
   let toolTurn = null;
+  const nestMedia = supportsFunctionResponseParts(model);
   for (const message of messages) {
     if (message?.role === 'tool') {
-      const { functionResponsePart, mediaParts } = toGeminiToolResult(message, toolNameByCallId);
+      const { functionResponsePart, mediaParts } = toGeminiToolResult(
+        message,
+        toolNameByCallId,
+        nestMedia,
+        callsByFinalId
+      );
       if (!toolTurn) {
         toolTurn = { content: { role: 'user', parts: [] }, responseCount: 0 };
         contents.push(toolTurn.content);
@@ -740,7 +1058,7 @@ export function toGeminiContents(messages, model = '', { repairToolSignatures =
       continue;
     }
     toolTurn = null;
-    const content = toGeminiContent(message);
+    const content = assistantContent.has(message) ? assistantContent.get(message) : toGeminiContent(message);
     if (content) contents.push(content);
   }
   return repairToolSignatures ? ensureGeminiToolCallSignatures(contents, model) : contents;

package/src/runtime/agent/orchestrator/providers/gemini-sdk-request.mjs

@@ -13,7 +13,6 @@ import {
   normalizeGeminiSdkError,
 } from './gemini-stream.mjs';
 import { geminiFailureUsage } from './gemini-response.mjs';
-import { geminiEndsWithFunctionResponse } from './gemini-retry-policy.mjs';
 
 export function geminiTextLeakGuardFor({ tools, callbacks }) {
   return createGeminiTextLeakGuard({
@@ -21,6 +20,7 @@ export function geminiTextLeakGuardFor({ tools, callbacks }) {
     onTextDelta: callbacks.onTextDelta,
     onToolCall: callbacks.onToolCall,
     onStreamDelta: callbacks.onStreamDelta,
+    deferToolCalls: true,
   });
 }
 
@@ -98,7 +98,6 @@ export async function streamGeminiSdkAttempt(genModel, stream, attemptSignal, on
       onTextDelta: callbacks.onTextDelta,
       textLeakGuard,
       label: 'Gemini SDK streamGenerateContent',
-      acceptEmptyNoFinish: geminiEndsWithFunctionResponse(contents),
       failureUsage: geminiFailureUsage(stream.opts, stream.cachedContent, stream.useModel),
       cancelGeneration: (reason) => {
         if (!controller.signal.aborted) controller.abort(reason);