mixdog 1.2.0 → 1.2.2

package/src/runtime/agent/orchestrator/providers/effort-configuration.mjs

@@ -1,4 +1,4 @@
-import { normalizeAnthropicEffortInput } from './anthropic-effort.mjs';
+import { anthropicEffortLevelsFor, normalizeAnthropicEffortInput } from './anthropic-effort.mjs';
 import { CUSTOM_EFFORT_LEVELS, customEffortLevels, isCustomProviderName } from './custom-reasoning.mjs';
 import { codexModelSupportsEffortUpdates } from './openai-oauth-catalog.mjs';
 
@@ -7,6 +7,9 @@ export const EFFORT_CONFIGURATION_BETA = 'mid-conversation-output-config-2026-07
 // first version checked on the wire (update accepted, prompt cache kept), and
 // every later version of that family. A model that turns out to reject the
 // update is switched off at runtime (markEffortConfigurationUnsupported).
+// The Anthropic catalogs publish no per-model flag for it, so a measured
+// floor is kept for the families already checked: below it the rejection is
+// certain, and every request would pay a failed attempt first.
 const ANTHROPIC_MIN_VERSION = Object.freeze({
   opus: [5, 0],
   sonnet: [5, 5],
@@ -14,6 +17,10 @@ const ANTHROPIC_MIN_VERSION = Object.freeze({
   fable: [5, 1],
   mythos: [5, 1],
 });
+// A family not measured yet starts at the earliest checked major, on the
+// routes that replay a rejected update (the rest cannot recover from one).
+const ANTHROPIC_FIRST_MAJOR = Math.min(...Object.values(ANTHROPIC_MIN_VERSION).map(([major]) => major));
+const ANTHROPIC_REPLAYING_PROVIDERS = new Set(['anthropic-oauth']);
 // https://developers.openai.com/api/docs/guides/reasoning#change-reasoning-mid-conversation
 // — GPT-6 and later, standard single-agent mode. The public API publishes no
 // per-model flag, so the version is its whole answer; the OAuth backend's
@@ -25,14 +32,19 @@ function versionAtLeast([major, minor], [minMajor, minMinor]) {
   return major > minMajor || (major === minMajor && minor >= minMinor);
 }
 
-function anthropicVersionSupported(id) {
+function anthropicVersionSupported(provider, id) {
   const m = id.match(/^claude-([a-z]+)-(\d+)(?:-(\d{1,2}))?$/);
-  const floor = m && ANTHROPIC_MIN_VERSION[m[1]];
-  return Boolean(floor) && versionAtLeast([Number(m[2]), Number(m[3] || 0)], floor);
+  if (!m) return false;
+  const version = [Number(m[2]), Number(m[3] || 0)];
+  const floor = ANTHROPIC_MIN_VERSION[m[1]];
+  if (floor) return versionAtLeast(version, floor);
+  return ANTHROPIC_REPLAYING_PROVIDERS.has(provider) && version[0] >= ANTHROPIC_FIRST_MAJOR;
 }
 
+// Any `gpt-<major>` id, whatever follows the major (tier names, minors,
+// snapshots), so a later naming scheme needs no edit.
 function openAiVersionSupported(id) {
-  const m = id.match(/^gpt-(\d+)(?:-\d+)?(?:-[a-z]+)?$/);
+  const m = id.match(/^gpt-(\d+)(?:-|$)/);
   return Boolean(m) && Number(m[1]) >= OPENAI_MIN_MAJOR;
 }
 
@@ -110,11 +122,25 @@ function openAiSupportsEffortUpdates(provider, model, id) {
   return declared ?? openAiVersionSupported(id);
 }
 
+// A custom route on the Responses wire (`opts.protocol`) serving GPT-6 or
+// later takes the same update as the official routes. The version is read
+// from the id's last `/` segment, so gateway ids like `openai/gpt-6.1-sol` count.
+function customResponsesSupportsEffortUpdates(provider, opts, id) {
+  return (
+    isCustomProviderName(provider) &&
+    opts.protocol === 'openai-responses' &&
+    openAiVersionSupported(id.slice(id.lastIndexOf('/') + 1))
+  );
+}
+
 export function effortConfigurationMode(provider, model, opts = {}) {
   const id = modelKey(model);
   if (opts.effortConfigurationEnabled === false || Number(opts.thinkingBudgetTokens) > 0) return null;
   if (unsupportedModels.has(`${provider}:${id}`)) return null;
-  if (OPENAI_PROVIDERS.has(provider) && openAiSupportsEffortUpdates(provider, model, id)) {
+  if (
+    (OPENAI_PROVIDERS.has(provider) && openAiSupportsEffortUpdates(provider, model, id)) ||
+    customResponsesSupportsEffortUpdates(provider, opts, id)
+  ) {
     const parameters = opts.modelParameters || {};
     const mode = opts.reasoning?.mode ?? parameters.reasoning_mode ?? parameters.mode ?? 'standard';
     if (mode !== 'standard' || opts.multiAgent === true || parameters.multi_agent === true) return null;
@@ -122,7 +148,7 @@ export function effortConfigurationMode(provider, model, opts = {}) {
   }
   if (
     ANTHROPIC_PROVIDERS.has(provider) &&
-    anthropicVersionSupported(id) &&
+    anthropicVersionSupported(provider, id) &&
     opts.disableBetaHeaders !== true &&
     (!opts.baseURL || /^https:\/\/api\.anthropic\.com(?:\/|$)/.test(opts.baseURL))
   )
@@ -132,7 +158,8 @@ export function effortConfigurationMode(provider, model, opts = {}) {
 
 // Custom providers on the Chat and Responses wires take a fresh effort with
 // every request, so auto effort sends a turn's or step's effort as that
-// request's own effort: no mid-conversation update, no beta header. A custom
+// request's own effort: no mid-conversation update, no beta header (except a
+// Responses-wire GPT-6+ model, which takes the 'responses' update). A custom
 // Anthropic-wire provider keeps auto effort off.
 const CUSTOM_AUTO_EFFORT_PROTOCOLS = new Set(['openai-chat', 'openai-responses']);
 
@@ -147,24 +174,38 @@ export function customAutoEffortCapable(provider, protocol, model) {
 }
 
 /** The model auto effort reads its effort options from: a custom provider's
- *  effective row (its declared levels), the bare id for every other route. */
+ *  effective row (its declared levels); an Anthropic route's id with the
+ *  levels the wire builder accepts (provider rows ignored); the bare id for every other route. */
 export function autoEffortModel(providerName, providerImpl, model) {
+  if (ANTHROPIC_PROVIDERS.has(providerName)) {
+    // The wire builder ignores provider rows on first-party routes, so the
+    // ladder is exactly what it accepts. `customReasoning` keeps an empty
+    // list from falling back to a family ladder.
+    return { id: model, reasoningLevels: anthropicEffortLevelsFor(model), customReasoning: true };
+  }
   if (!isCustomProviderName(providerName)) return { id: model };
   return { ...(providerImpl?.getCachedModelInfo?.(model) || {}), id: model };
 }
 
 /** The effort-change mode of a session's route: 'responses' / 'anthropic'
- *  (mid-conversation update), 'custom' (per-request effort), or null. */
+ *  (mid-conversation update), 'custom' (per-request effort), or null. A
+ *  custom route takes an update mode only when its model declares levels. */
 export function turnEffortConfigurationMode(session, provider) {
-  const opts = { ...(provider?.config || {}), modelParameters: session.modelParameters || {} };
+  const protocol = provider?.customConfig?.protocol;
+  const opts = { ...(provider?.config || {}), modelParameters: session.modelParameters || {}, protocol };
+  const custom = customAutoEffortCapable(
+    session.provider,
+    protocol,
+    autoEffortModel(session.provider, provider, session.model)
+  );
   const mode = effortConfigurationMode(session.provider, session.model, opts);
-  if (mode) return mode;
-  const model = autoEffortModel(session.provider, provider, session.model);
-  return customAutoEffortCapable(session.provider, provider?.customConfig?.protocol, model) ? 'custom' : null;
+  if (mode && (custom || !isCustomProviderName(session.provider))) return mode;
+  return custom ? 'custom' : null;
 }
 
 const CUSTOM_EFFORTS = new Set(CUSTOM_EFFORT_LEVELS);
-const effortsFor = (mode) => (mode === 'custom' ? CUSTOM_EFFORTS : EFFORTS);
+// A custom route keeps its own levels (including `none`) in either mode.
+const effortsFor = (mode, provider) => (mode === 'custom' || isCustomProviderName(provider) ? CUSTOM_EFFORTS : EFFORTS);
 
 function normalizedEffort(provider, model, effort) {
   if (ANTHROPIC_PROVIDERS.has(provider)) return normalizeAnthropicEffortInput(effort, model) || null;
@@ -180,8 +221,8 @@ function validSnapshot(value, provider, model, mode) {
     value.provider === provider &&
     value.model === modelKey(model) &&
     value.mode === mode &&
-    effortsFor(mode).has(value.initialEffort) &&
-    effortsFor(mode).has(value.effort)
+    effortsFor(mode, provider).has(value.initialEffort) &&
+    effortsFor(mode, provider).has(value.effort)
   );
 }
 
@@ -192,7 +233,7 @@ function validSnapshot(value, provider, model, mode) {
 export function prepareTurnEffortConfiguration(session, provider, turnEffort) {
   const mode = turnEffortConfigurationMode(session, provider);
   const effort = normalizedEffort(session.provider, session.model, turnEffort ?? session.effort);
-  if (!mode || !effortsFor(mode).has(effort)) return null;
+  if (!mode || !effortsFor(mode, session.provider).has(effort)) return null;
   const first = (session.messages || []).find((message) =>
     validSnapshot(message?.meta?.[META_KEY], session.provider, session.model, mode)
   )?.meta?.[META_KEY];
@@ -214,7 +255,7 @@ export function prepareTurnEffortConfiguration(session, provider, turnEffort) {
 // step), or null when that effort is not valid for the model.
 export function stepEffortConfiguration(snapshot, provider, model, effort) {
   const value = normalizedEffort(provider, model, effort);
-  if (!snapshot || !EFFORTS.has(value)) return null;
+  if (!snapshot || !effortsFor(snapshot.mode, provider).has(value)) return null;
   return { ...snapshot, effort: value };
 }
 
@@ -249,6 +290,32 @@ export function projectEffortConfiguration(messages, provider, model, opts = {})
   return { mode, initialEffort: seed.initialEffort, effort: current, updates };
 }
 
+/**
+ * Responses-wire placement of a projection's updates while a history is
+ * lowered in order: `before(message)` gives the items to emit ahead of a
+ * message, `end()` those after the last one. An update on a tool result
+ * applies after its whole batch; one on a user message before it. Adjacent
+ * updates are rejected, so a batch update that a user message directly
+ * follows yields to that message's own.
+ */
+export function responsesEffortUpdates(projection) {
+  let afterBatch = null;
+  const items = (effort) => (effort ? [{ type: 'configuration_update', reasoning: { effort } }] : []);
+  return {
+    before(message) {
+      const effort = projection?.updates.get(message);
+      if (message.role === 'tool') {
+        if (effort) afterBatch = effort;
+        return [];
+      }
+      const value = effort || afterBatch;
+      afterBatch = null;
+      return items(value);
+    },
+    end: () => items(afterBatch),
+  };
+}
+
 // Split only before a user message or after a whole tool-result batch.
 // Sanitizing each segment before inserting the trusted empty system control
 // avoids losing it as empty text, and never separates a tool call from its

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

@@ -252,7 +252,7 @@ export function dropRejectedGeminiCache(cachedContent, opts) {
 // the model-specific minimum. Skip the POST entirely when the estimate
 // is under threshold so we don't spam 400 responses turn-after-turn.
 export function geminiPrefixBelowMinimum({ model, systemInstruction, geminiTools, contents, opts, currentIter }) {
-  const minTokens = _geminiCacheMinTokens(model);
+  const minTokens = _geminiCacheMinTokens();
   const estimatedTokens = _estimateGeminiCacheTokens(systemInstruction, geminiTools, contents);
   if (estimatedTokens >= minTokens) return false;
   traceGeminiCache(opts, currentIter, 'gemini_cache_skip', {

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

@@ -43,12 +43,11 @@ function summarizeTraceContents(contents) {
   return [...summaries.slice(0, 8), { omittedTurns: summaries.length - 12 }, ...summaries.slice(-4)];
 }
 
-// Gemini cachedContents API rejects prefixes below the model-specific minimum
-// (Gemini 2.0/2.5 = 2048 tokens, Gemini 3.x = 4096 tokens) with HTTP 400
-// "Cached content is too small". Estimating chars/4 ≈ tokens lets us skip the
-// roundtrip when the prefix cannot satisfy the invariant. Estimate undercount
-// is harmless (we attempt and get the same 400 we would have skipped); overcount
-// is harmless (we skip, fall back to implicit cache).
+// Gemini cachedContents API rejects prefixes below a model-specific minimum
+// with HTTP 400 "Cached content is too small". Estimating chars/4 ≈ tokens
+// lets us skip the roundtrip when the prefix cannot satisfy the invariant.
+// Estimate undercount is harmless (we attempt and get the same 400 we would
+// have skipped); overcount is harmless (we skip, fall back to implicit cache).
 export function _estimateGeminiCacheTokens(systemInstruction, geminiTools, contents) {
   let chars = 0;
   if (typeof systemInstruction === 'string') chars += systemInstruction.length;
@@ -67,8 +66,15 @@ export function _estimateGeminiCacheTokens(systemInstruction, geminiTools, conte
   return Math.ceil(chars / 4);
 }
 
-export function _geminiCacheMinTokens(model) {
-  return /^gemini-3/i.test(String(model || '')) ? 4096 : 2048;
+// No catalog publishes the cachedContents floor and the published minimums
+// differ per model and change between releases, so one floor serves every id:
+// the highest published minimum. Skipping a small prefix only falls back to the
+// implicit cache, whereas a floor that is too low would POST a create that the
+// server rejects on every turn.
+const GEMINI_CACHE_MIN_TOKENS = 4096;
+
+export function _geminiCacheMinTokens() {
+  return GEMINI_CACHE_MIN_TOKENS;
 }
 
 export function _geminiCachePrefixCount(contents) {
@@ -110,6 +116,21 @@ const GEMINI_GLOBAL_CACHE_MAX_ENTRIES = 128;
 export const GEMINI_GLOBAL_CACHE_DELETE_GRACE_MS = 2 * 60 * 1000;
 const geminiGlobalCaches = new Map();
 export const geminiGlobalCacheCreates = new Map();
+// Models whose cachedContents.create the server refused as unsupported (not
+// a prefix or quota failure). No catalog publishes explicit-cache support, so
+// the server's own answer decides, once per process.
+const geminiExplicitCacheRefusedModels = new Set();
+
+export function markGeminiExplicitCacheRefused(model, err) {
+  if (err?.status !== 400) return false;
+  if (!/explicit caching is not supported/i.test(String(err?.message || ''))) return false;
+  geminiExplicitCacheRefusedModels.add(String(model || ''));
+  return true;
+}
+
+export function geminiExplicitCacheRefused(model) {
+  return geminiExplicitCacheRefusedModels.has(String(model || ''));
+}
 
 export function _geminiCredentialFingerprint(apiKey) {
   return traceHash(String(apiKey || ''));

package/src/runtime/agent/orchestrator/providers/gemini-error-contract.mjs

@@ -0,0 +1,191 @@
+/**
+ * gemini-error-contract.mjs — Google RPC error details → the provider error
+ * contract shared by Gemini (REST + SDK) and Antigravity:
+ *   status, code (lowercased), retryAfterMs (uncapped), resetAt (epoch ms),
+ *   quotaScope ('minute' | 'day' | undefined).
+ *
+ * Details come from `error.details` (REST body) or `errorDetails` (SDK
+ * GoogleGenerativeAIFetchError). Entries are google.rpc.RetryInfo,
+ * QuotaFailure and ErrorInfo.
+ */
+
+const DURATION_RE = /^(?:\d+(?:\.\d+)?(?:ms|s|m|h))+$/;
+const DURATION_PART_RE = /(\d+(?:\.\d+)?)(ms|s|m|h)/g;
+const DURATION_UNIT_MS = { ms: 1, s: 1000, m: 60_000, h: 3_600_000 };
+const BARE_SECONDS_RE = /^\d+(?:\.\d+)?$/;
+
+// Google error classification: a per-minute quota with no RetryInfo is
+// retried after one quota window.
+export const GEMINI_PER_MINUTE_RETRY_MS = 60_000;
+
+// "Please retry in 34.07s" (Gemini API) / "reset after 2h1m1s" (Cloud Code).
+const MESSAGE_DELAY_RE = /(?:please retry in|reset after)\s+((?:\d+(?:\.\d+)?(?:ms|h|m|s))+)/i;
+const LIMIT_ZERO_RE = /limit:\s*0(?!\d|\.\d)/i;
+const CAPACITY_MESSAGE_RE = /exhausted your capacity|capacity exceeded|model_capacity_exhausted/i;
+// ErrorInfo reasons that name a spent quota with no window of its own.
+const TERMINAL_REASONS = new Set(['quota_exhausted', 'insufficient_g1_credits_balance']);
+const CAPACITY_REASONS = new Set(['model_capacity_exhausted', 'model_capacity_exceeded']);
+
+const GOOGLE_STATUS_HTTP = {
+  INVALID_ARGUMENT: 400,
+  UNAUTHENTICATED: 401,
+  PERMISSION_DENIED: 403,
+  NOT_FOUND: 404,
+  RESOURCE_EXHAUSTED: 429,
+  INTERNAL: 500,
+  UNAVAILABLE: 503,
+  DEADLINE_EXCEEDED: 504,
+};
+
+function detailType(entry) {
+  return typeof entry?.['@type'] === 'string' ? entry['@type'] : '';
+}
+
+function durationMs(value) {
+  if (typeof value === 'string') {
+    const text = value.trim();
+    if (BARE_SECONDS_RE.test(text)) return Math.ceil(Number(text) * 1000);
+    if (!DURATION_RE.test(text)) return null;
+    let total = 0;
+    for (const [, amount, unit] of text.matchAll(DURATION_PART_RE)) total += Number(amount) * DURATION_UNIT_MS[unit];
+    return Math.ceil(total);
+  }
+  if (value && typeof value === 'object') {
+    const ms = Number(value.seconds || 0) * 1000 + Number(value.nanos || 0) / 1_000_000;
+    return Number.isFinite(ms) && ms >= 0 ? Math.ceil(ms) : null;
+  }
+  return null;
+}
+
+// A zero wait is no advice: the caller's normal backoff (or the per-minute
+// window) applies instead of an immediate re-issue.
+function adviceMs(value) {
+  const ms = durationMs(value);
+  return ms > 0 ? ms : undefined;
+}
+
+function scopeOf(text) {
+  if (/per[\s_-]?day|daily/i.test(text)) return 'day';
+  if (/per[\s_-]?minute/i.test(text)) return 'minute';
+  return undefined;
+}
+
+/**
+ * `quotaScope` is 'minute' / 'day' from the typed quota ids only (never from
+ * the length of the server's wait); 'plan' marks a spent
+ * quota with no window (ErrorInfo QUOTA_EXHAUSTED, or a QuotaFailure
+ * violation with a zero limit; message prose alone never counts). Capacity
+ * (MODEL_CAPACITY_EXHAUSTED / "exhausted your capacity") is an overload of the
+ * shared pool: code `model_capacity_exhausted`, never a quota scope.
+ * @param {{ details?: unknown, errorDetails?: unknown, googleStatus?: string, message?: string }} input
+ * @returns {{ code?: string, retryAfterMs?: number, resetAt?: number, quotaScope?: 'minute'|'day'|'plan' }}
+ */
+export function geminiErrorContract({ details, errorDetails, googleStatus, message } = {}) {
+  const list = [details, errorDetails].flatMap((entry) => (Array.isArray(entry) ? entry : []));
+  let reason = '';
+  let retryAfterMs;
+  let resetAt;
+  const scopes = new Set();
+  let zeroLimit = false;
+  for (const entry of list) {
+    const type = detailType(entry);
+    if (type.endsWith('.RetryInfo') || entry?.retryDelay !== undefined) {
+      retryAfterMs ??= adviceMs(entry.retryDelay);
+    }
+    if (type.endsWith('.QuotaFailure') || Array.isArray(entry?.violations)) {
+      for (const violation of entry.violations || []) {
+        const scope = scopeOf(String(violation?.quotaId || ''));
+        if (scope) scopes.add(scope);
+        // A spent allowance is named by the typed violation, not by prose.
+        if (String(violation?.quotaValue ?? '').trim() === '0' || LIMIT_ZERO_RE.test(String(violation?.description || ''))) {
+          zeroLimit = true;
+        }
+      }
+    }
+    if (type.endsWith('.ErrorInfo') || typeof entry?.reason === 'string') {
+      if (!reason && typeof entry.reason === 'string') reason = entry.reason.trim().toLowerCase();
+      const metadata = entry.metadata && typeof entry.metadata === 'object' ? entry.metadata : {};
+      retryAfterMs ??= adviceMs(metadata.quotaResetDelay);
+      const stamp = Date.parse(String(metadata.quotaResetTimeStamp || ''));
+      if (resetAt === undefined && Number.isFinite(stamp)) resetAt = stamp;
+      const scope = scopeOf(
+        [metadata.quotaId, metadata.quota_limit, metadata.quota_metric, entry.reason].filter(Boolean).join(' ')
+      );
+      if (scope) scopes.add(scope);
+    }
+  }
+  const text = typeof message === 'string' ? message : '';
+  // The message names capacity only when nothing typed said otherwise (a
+  // reason, a quota id or RetryInfo outranks it, as in classifyGoogleError).
+  const capacity =
+    CAPACITY_REASONS.has(reason) ||
+    (!reason && scopes.size === 0 && retryAfterMs === undefined && CAPACITY_MESSAGE_RE.test(text));
+  // A per-day violation outlasts any per-minute one reported with it.
+  let quotaScope = scopes.has('day') ? 'day' : scopes.has('minute') ? 'minute' : undefined;
+  if (retryAfterMs === undefined) {
+    const named = MESSAGE_DELAY_RE.exec(text);
+    if (named) retryAfterMs = adviceMs(named[1]);
+  }
+  // Per-minute quota with no RetryInfo: wait one quota window.
+  if (retryAfterMs === undefined && quotaScope === 'minute' && !capacity) retryAfterMs = GEMINI_PER_MINUTE_RETRY_MS;
+  if (resetAt === undefined && retryAfterMs !== undefined) resetAt = Date.now() + retryAfterMs;
+  if (!capacity && !quotaScope && (TERMINAL_REASONS.has(reason) || zeroLimit)) quotaScope = 'plan';
+  const status = typeof googleStatus === 'string' ? googleStatus.trim().toLowerCase() : '';
+  const code = capacity ? 'model_capacity_exhausted' : reason || status;
+  return {
+    ...(code ? { code } : {}),
+    ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
+    ...(resetAt !== undefined ? { resetAt } : {}),
+    ...(quotaScope ? { quotaScope } : {}),
+  };
+}
+
+/** Copy the contract fields onto `err`; an already-typed `code` is kept. */
+export function applyGeminiErrorContract(err, input) {
+  const { code, ...rest } = geminiErrorContract(input);
+  Object.assign(err, rest);
+  if (code && !(typeof err.code === 'string' && err.code)) err.code = code;
+  return err;
+}
+
+/**
+ * The `{ error: {...} }` envelope a Gemini/Cloud Code stream carries in-band
+ * instead of an HTTP error status. Returns the typed error, or null when the
+ * chunk is an ordinary payload.
+ */
+export function geminiInBandError(chunk, label) {
+  const detail = chunk && typeof chunk === 'object' ? chunk.error : null;
+  if (!detail || (typeof detail !== 'object' && typeof detail !== 'string')) return null;
+  const body = typeof detail === 'object' ? detail : { message: detail };
+  const googleStatus = typeof body.status === 'string' ? body.status : '';
+  const status = Number.isFinite(Number(body.code)) && Number(body.code) > 0
+    ? Number(body.code)
+    : GOOGLE_STATUS_HTTP[googleStatus.toUpperCase()];
+  const err = new Error(`${label} in-band error${status ? ` ${status}` : ''}: ${String(body.message || googleStatus || 'unknown').slice(0, 300)}`);
+  err.name = 'GeminiInBandError';
+  if (status) {
+    err.status = status;
+    err.httpStatus = status;
+  }
+  if (googleStatus) err.geminiStatus = googleStatus.toUpperCase();
+  err.error = body;
+  const details = body.details ?? body.errorDetails;
+  if (Array.isArray(details)) err.details = details;
+  return applyGeminiErrorContract(err, { details, googleStatus, message: body.message });
+}
+
+/** Throw the typed in-band error when `chunk` is an error envelope. */
+export function assertNoGeminiInBandError(chunk, label) {
+  const err = geminiInBandError(chunk, label);
+  if (err) throw err;
+}
+
+const SAFETY_FINISH = /^(?:PROMPT_)?(?:SAFETY|IMAGE_SAFETY|BLOCKLIST|PROHIBITED_CONTENT|SPII|IMAGE_PROHIBITED_CONTENT)$/;
+
+/** Policy-refusal code for a finishReason, or null for any other reason. */
+export function geminiPolicyFinishCode(finishReason) {
+  const reason = String(finishReason || '').replace(/^FINISH_REASON_/, '');
+  if (SAFETY_FINISH.test(reason)) return 'safety';
+  if (/^(?:PROMPT_)?RECITATION$/.test(reason)) return 'recitation';
+  return null;
+}

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

@@ -0,0 +1,9 @@
+// True for an id in the Gemini wire family ("gemini-4-argon", "models/gemini-3.1-pro",
+// "gemini-pro-agent"). It names the family only, never a generation: it separates
+// Gemini from the other model families an Antigravity gateway serves (Claude,
+// GPT-OSS), which reject Gemini-only request fields outright.
+const GEMINI_FAMILY = /(?:^|\/)gemini-/i;
+
+export function isGeminiFamilyModel(model) {
+  return GEMINI_FAMILY.test(String(model || ''));
+}

package/src/runtime/agent/orchestrator/providers/gemini-history-signatures.mjs

@@ -1,10 +1,15 @@
+import { isGeminiFamilyModel } from './gemini-family.mjs';
+
 const SYNTHETIC_TOOL_SIGNATURE = 'skip_thought_signature_validator';
 
-// Gemini 3 validates the first functionCall in every step of the current turn.
-// Foreign/interrupted histories may not have a native signature for that call.
-// Preserve real signatures and unsigned siblings of a signed parallel batch.
+// Gemini models that validate thought signatures check the first functionCall
+// in every step of the current turn. Foreign/interrupted histories may not have
+// a native signature for that call. Preserve real signatures and unsigned
+// siblings of a signed parallel batch. The validator-bypass token is a Gemini
+// wire token: it is only fabricated for the Gemini family, because the other
+// families an Antigravity gateway serves reject it.
 export function ensureGeminiToolCallSignatures(contents, model) {
-  if (!/^(?:models\/)?gemini-3(?:[.-]|$)/i.test(String(model || ''))) return contents;
+  if (!isGeminiFamilyModel(model)) return contents;
   let activeTurnStart = 0;
   for (let index = contents.length - 1; index >= 0; index -= 1) {
     const content = contents[index];

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

@@ -14,6 +14,7 @@ import { createProviderReplay } from './lib/provider-replay.mjs';
 import { collectGeminiGroundingSources, parseGeminiTextPartMetadata, parseToolCalls } from './gemini-schema.mjs';
 import { _resolveGeminiCacheUsage } from './gemini-cache.mjs';
 import { traceGeminiCache } from './gemini-cache-policy.mjs';
+import { geminiPolicyFinishCode } from './gemini-error-contract.mjs';
 
 // Candidate text and tool calls after the text-leak guard: leaked
 // (text-embedded) tool calls are appended to the native ones and empty the
@@ -64,7 +65,8 @@ export function geminiIncompleteError(response, parsed, useModel, usage = null)
   if (!finishReason || normalizedFinishReason === 'STOP') return null;
   return Object.assign(new Error(`Gemini response incomplete: finishReason=${finishReason}`), {
     name: 'ProviderIncompleteError',
-    code: 'PROVIDER_INCOMPLETE',
+    // Safety/recitation are policy refusals the core presents as such.
+    code: geminiPolicyFinishCode(finishReason) || 'PROVIDER_INCOMPLETE',
     providerIncomplete: true,
     finishReason,
     partialContent: parsed.content,