mixdog 1.2.1 → 1.2.2

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

@@ -0,0 +1,180 @@
+/**
+ * gemini-retry-policy.mjs — Gemini API retry constants and the two-phase
+ * attempt loop (request backoff and stream retry):
+ *
+ *   connection phase  up to 10 attempts, 5s initial delay doubling to a 30s
+ *                     cap, ±30% jitter (a server-advised wait replaces it);
+ *   stream phase      a failure after the response opened (a stream that ends
+ *                     with no finish reason is one: the transport raises it as
+ *                     a truncated stream), or a response the model left
+ *                     unusable (malformed / unexpected tool call, empty text),
+ *                     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
+ *                     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
+ *                     (provider-terminal, no quota scope; the wait stays on
+ *                     the error for display).
+ *
+ * Replay stays gated by the stream-outcome contract: a stream that exposed
+ * text or dispatched a tool is never re-issued.
+ */
+import { readStreamOutcome } from './lib/stream-outcome.mjs';
+import { DETERMINISTIC_KINDS, providerErrorKind, typedCodeKind } from './provider-error-kind.mjs';
+import { midstreamRetryDelayMs } from './retry-backoff.mjs';
+import { classifyError, markProviderRecoveryExhausted, sleepWithAbort, withRetry } from './retry-classifier.mjs';
+
+export const GEMINI_REQUEST_RETRY = Object.freeze({
+  maxAttempts: 10,
+  // Wait before retry N reads index N (the leading 5s covers index 0 and 1):
+  // 5s, 10s, 20s, then the 30s cap.
+  backoffMs: Object.freeze([5000, 5000, 10_000, 20_000, 30_000]),
+  retryJitterRatio: 0.3,
+  // Server advice gets positive-only jitter and is never below the step.
+  retryAfterJitterRatio: 0.2,
+  adviceAtLeastBackoff: true,
+  retry499: true,
+});
+
+// A server wait longer than this is a lock-out, not a retry.
+export const GEMINI_MAX_RETRYABLE_ADVICE_MS = 300_000;
+
+function hasLongAdvice(err) {
+  const { kind, retryAfterMs } = providerErrorKind(err);
+  return retryAfterMs > GEMINI_MAX_RETRYABLE_ADVICE_MS && !DETERMINISTIC_KINDS.has(kind);
+}
+
+/** True when the request's last turn is a tool result (functionResponse). */
+export function geminiEndsWithFunctionResponse(contents) {
+  const last = Array.isArray(contents) ? contents[contents.length - 1] : null;
+  return Array.isArray(last?.parts) && last.parts.some((part) => part?.functionResponse);
+}
+
+export const GEMINI_MIDSTREAM_MAX_ATTEMPTS = 4;
+export const GEMINI_MIDSTREAM_INITIAL_DELAY_MS = 1000;
+
+const midstreamStepMs = (streamAttempt) => GEMINI_MIDSTREAM_INITIAL_DELAY_MS * 2 ** streamAttempt;
+
+/**
+ * Wait before re-issuing after a stream-phase failure, or null when it must
+ * surface. A server-advised wait on a retryable kind replaces the step.
+ */
+export function geminiMidstreamDelayMs(err, streamAttempt, signal = null) {
+  if (streamAttempt + 1 >= GEMINI_MIDSTREAM_MAX_ATTEMPTS || signal?.aborted) return null;
+  if (readStreamOutcome(err).replaySafe !== true) return null;
+  const { kind } = providerErrorKind(err);
+  if (hasLongAdvice(err)) return null;
+  // A status-only 499 (client closed request) is retried, as on the request
+  // ladder; a typed code on the 499 keeps it final.
+  const closed499 =
+    GEMINI_REQUEST_RETRY.retry499 && kind === 'invalid_request' && statusOf(err) === 499 && !typedCodeKind(err);
+  if (DETERMINISTIC_KINDS.has(kind) && !closed499) return null;
+  // 429 is request-local here: classifyError calls it permanent, but a rate
+  // limit that is not a spent quota is retried like any other stream fault.
+  if (!closed499 && classifyError(err) !== 'transient' && kind !== 'rate_limited') return null;
+  return midstreamRetryDelayMs(err, midstreamStepMs(streamAttempt));
+}
+
+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).
+ */
+export function geminiInvalidStreamReason(response, textLeakGuard = null, { afterToolResult = false } = {}) {
+  const candidate = response?.candidates?.[0];
+  const parts = Array.isArray(candidate?.content?.parts) ? candidate.content.parts : [];
+  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;
+  // Right after a tool result the model may legitimately answer with nothing.
+  if (afterToolResult) return null;
+  const text = parts
+    .filter((part) => part?.thought !== true && typeof part?.text === 'string')
+    .map((part) => part.text)
+    .join('')
+    .replace(/[\u200B-\u200D\uFEFF\u200E\u200F]/g, '')
+    .trim();
+  return text ? null : 'NO_RESPONSE_TEXT';
+}
+
+/**
+ * Run `run` under the Gemini ladder. `run({ signal, connected })` performs one
+ * open + consume and calls `connected()` once the response opened; it resolves
+ * `{ response, textLeakGuard }`.
+ */
+export async function runGeminiStreamAttempts({ run, signal, onRetry, sleepFn, afterToolResult = false }) {
+  for (let streamAttempt = 0; ; streamAttempt++) {
+    let connected = false;
+    let result;
+    try {
+      result = await withRetry(
+        async ({ signal: attemptSignal }) => {
+          try {
+            return await run({
+              signal: attemptSignal,
+              connected: () => {
+                connected = true;
+              },
+            });
+          } catch (err) {
+            // A server wait over the limit ends recovery on either phase.
+            if (hasLongAdvice(err)) {
+              throw markProviderRecoveryExhausted(err, {
+                owner: connected ? 'gemini-stream' : 'gemini-connection',
+                terminal: true,
+              });
+            }
+            // The connection ladder is spent on opening; a stream-phase
+            // failure belongs to the stream ladder below.
+            throw connected ? markProviderRecoveryExhausted(err, { owner: 'gemini-connection' }) : err;
+          }
+        },
+        { ...GEMINI_REQUEST_RETRY, finalOnExhaust: true, signal, sleepFn, onRetry }
+      );
+    } catch (err) {
+      const waitMs = connected ? geminiMidstreamDelayMs(err, streamAttempt, signal) : null;
+      if (waitMs == null) throw err;
+      onRetry?.({ attempt: streamAttempt + 1, maxAttempts: GEMINI_MIDSTREAM_MAX_ATTEMPTS, lastErr: err, delayMs: waitMs });
+      await sleepWithAbort(waitMs, signal, sleepFn, 'Gemini stream retry wait aborted');
+      continue;
+    }
+    const invalid = geminiInvalidStreamReason(result.response, result.textLeakGuard, { afterToolResult });
+    if (!invalid || signal?.aborted) return result;
+    const unusable = Object.assign(new Error(`Gemini stream unusable: ${invalid}`), {
+      name: 'InvalidStreamError',
+      code: invalid.toLowerCase(),
+    });
+    if (streamAttempt + 1 >= GEMINI_MIDSTREAM_MAX_ATTEMPTS) {
+      // A spent ladder on an empty answer is a failure, not an answer; a
+      // malformed / unexpected tool call keeps its finish-reason error.
+      if (invalid !== 'NO_RESPONSE_TEXT') return result;
+      throw markProviderRecoveryExhausted(unusable, {
+        owner: 'gemini-stream',
+        attempts: GEMINI_MIDSTREAM_MAX_ATTEMPTS,
+        terminal: true,
+      });
+    }
+    const waitMs = midstreamStepMs(streamAttempt);
+    onRetry?.({
+      attempt: streamAttempt + 1,
+      maxAttempts: GEMINI_MIDSTREAM_MAX_ATTEMPTS,
+      lastErr: unusable,
+      delayMs: waitMs,
+    });
+    await sleepWithAbort(waitMs, signal, sleepFn, 'Gemini stream retry wait aborted');
+  }
+}

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

@@ -66,49 +66,6 @@ function splitGeminiToolContent(content) {
   };
 }
 
-const GEMINI_FUNCTION_RESPONSE_MIME = /^(?:image\/(?:png|jpeg|webp)|application\/pdf|text\/plain)$/i;
-
-function geminiFunctionCapabilities(model) {
-  const match = String(model || '')
-    .toLowerCase()
-    .match(/(?:^|\/)gemini(?:-live)?-(\d+)/);
-  const major = match ? Number.parseInt(match[1], 10) : null;
-  const modern = major == null || major >= 3;
-  return {
-    functionPartIds: modern,
-    multimodalFunctionResponse: modern,
-  };
-}
-
-function toGeminiFunctionResponseMedia(mediaParts) {
-  const parts = [];
-  const refs = [];
-  const external = [];
-  const omitted = [];
-  for (const media of mediaParts || []) {
-    const payload = media?.inlineData || media?.fileData;
-    const mimeType = String(payload?.mimeType || '').trim();
-    if (!GEMINI_FUNCTION_RESPONSE_MIME.test(mimeType)) {
-      if (mimeType) omitted.push(mimeType);
-      continue;
-    }
-    const displayName = `tool_media_${parts.length + 1}`;
-    if (media.inlineData) {
-      parts.push({ inlineData: { ...media.inlineData, mimeType, displayName } });
-      refs.push({ $ref: displayName });
-    } else {
-      // FunctionResponse.parts currently documents inlineData only.
-      // fileData is valid in ordinary Content parts but can 400 when
-      // nested here, so retain file-backed media as plain JSON metadata.
-      external.push({
-        mimeType,
-        fileUri: String(media.fileData?.fileUri || ''),
-      });
-    }
-  }
-  return { parts, refs, external, omitted };
-}
-
 /**
  * Convert JSON Schema type string to Gemini SchemaType.
  * Gemini SDK uses its own enum instead of plain strings.
@@ -647,27 +604,18 @@ export function toGeminiToolConfig(toolChoice) {
   return undefined;
 }
 
-function toGeminiToolContent(message, toolNameByCallId, capabilities) {
+// 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) {
   const functionName = toolNameByCallId?.get(message.toolCallId) || message.toolCallId || '';
   const { response, mediaParts } = splitGeminiToolContent(message.content);
-  const media = toGeminiFunctionResponseMedia(mediaParts);
-  if (media.refs.length) response.media = media.refs;
-  if (media.external.length) response.externalMedia = media.external;
-  if (media.omitted.length) response.omittedMediaTypes = media.omitted;
   const functionResponse = { name: functionName, response };
-  if (capabilities.functionPartIds && typeof message.toolCallId === 'string' && message.toolCallId) {
-    functionResponse.id = message.toolCallId;
-  }
-  if (capabilities.multimodalFunctionResponse && media.parts.length) {
-    functionResponse.parts = media.parts;
-  }
-  return {
-    content: { role: 'user', parts: [{ functionResponse }] },
-    trailingMediaParts: capabilities.multimodalFunctionResponse ? [] : media.parts,
-  };
+  if (typeof message.toolCallId === 'string' && message.toolCallId) functionResponse.id = message.toolCallId;
+  return { functionResponsePart: { functionResponse }, mediaParts };
 }
 
-function toGeminiContent(message, capabilities) {
+function toGeminiContent(message) {
   if (!message || message.role === 'system') return null;
   const orderedReplay =
     message.role === 'assistant' ? providerReplayItems(message, ['gemini', 'antigravity']) : undefined;
@@ -689,7 +637,7 @@ function toGeminiContent(message, capabilities) {
         functionCall: {
           name: tc.name,
           args: tc.arguments,
-          ...(capabilities.functionPartIds && typeof tc.id === 'string' && tc.id ? { id: tc.id } : {}),
+          ...(typeof tc.id === 'string' && tc.id ? { id: tc.id } : {}),
         },
       };
       if (
@@ -765,7 +713,6 @@ function geminiThoughtPartsFromMetadata(message) {
 
 export function toGeminiContents(messages, model = '', { repairToolSignatures = true } = {}) {
   const contents = [];
-  const capabilities = geminiFunctionCapabilities(model);
   // Map synthetic toolCallId -> function name from prior assistant
   // tool_calls so each functionResponse part carries the real function name.
   const toolNameByCallId = new Map();
@@ -776,34 +723,26 @@ export function toGeminiContents(messages, model = '', { repairToolSignatures =
       }
     }
   }
-  let pendingToolMediaParts = [];
-  const flushToolMedia = () => {
-    if (!pendingToolMediaParts.length) return;
-    contents.push({ role: 'user', parts: pendingToolMediaParts });
-    pendingToolMediaParts = [];
-  };
+  // 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;
   for (const message of messages) {
     if (message?.role === 'tool') {
-      const { content, trailingMediaParts } = toGeminiToolContent(message, toolNameByCallId, capabilities);
-      const last = contents[contents.length - 1];
-      if (
-        last?.role === 'user' &&
-        Array.isArray(last.parts) &&
-        last.parts.length &&
-        last.parts.every((part) => part?.functionResponse)
-      ) {
-        last.parts.push(...content.parts);
-      } else {
-        contents.push(content);
+      const { functionResponsePart, mediaParts } = toGeminiToolResult(message, toolNameByCallId);
+      if (!toolTurn) {
+        toolTurn = { content: { role: 'user', parts: [] }, responseCount: 0 };
+        contents.push(toolTurn.content);
       }
-      pendingToolMediaParts.push(...trailingMediaParts);
+      toolTurn.content.parts.splice(toolTurn.responseCount, 0, functionResponsePart);
+      toolTurn.responseCount += 1;
+      toolTurn.content.parts.push(...mediaParts);
       continue;
     }
-    flushToolMedia();
-    const content = toGeminiContent(message, capabilities);
+    toolTurn = null;
+    const content = toGeminiContent(message);
     if (content) contents.push(content);
   }
-  flushToolMedia();
   return repairToolSignatures ? ensureGeminiToolCallSignatures(contents, model) : contents;
 }
 

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

@@ -13,6 +13,7 @@ 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({
@@ -71,7 +72,7 @@ function linkSdkRequestController(attemptSignal) {
   return { controller, detachParent, clearConnectTimer };
 }
 
-export async function streamGeminiSdkAttempt(genModel, stream, attemptSignal) {
+export async function streamGeminiSdkAttempt(genModel, stream, attemptSignal, onConnected = null) {
   const { contents, callbacks } = stream;
   const link = linkSdkRequestController(attemptSignal);
   const { controller } = link;
@@ -89,6 +90,7 @@ export async function streamGeminiSdkAttempt(genModel, stream, attemptSignal) {
     // the parent link attached so a later abort during streaming still
     // reaches the request.
     link.clearConnectTimer();
+    onConnected?.();
     const textLeakGuard = geminiTextLeakGuardFor(stream);
     const response = await consumeGeminiSdkStream(streamResult, {
       signal: attemptSignal,
@@ -96,6 +98,7 @@ export async function streamGeminiSdkAttempt(genModel, stream, attemptSignal) {
       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);

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

@@ -26,6 +26,7 @@ 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';
 
 export const GEMINI_FIRST_BYTE_TIMEOUT_MS = resolveTimeoutMs(
   'MIXDOG_GEMINI_FIRST_BYTE_TIMEOUT_MS',
@@ -132,9 +133,16 @@ export function normalizeGeminiSdkError(err, label) {
   const transport = geminiSdkTransportError(err, label);
   if (transport) return transport;
   const stamped = stampGeminiRpcError(err);
-  return isGeminiSdkStreamParseError(stamped)
-    ? geminiStreamCorruptionError(`${label} corrupt SDK SSE JSON`, stamped)
-    : stamped;
+  if (isGeminiSdkStreamParseError(stamped)) {
+    return geminiStreamCorruptionError(`${label} corrupt SDK SSE JSON`, stamped);
+  }
+  if (!stamped || typeof stamped !== 'object') return stamped;
+  return applyGeminiErrorContract(stamped, {
+    details: stamped.details,
+    errorDetails: stamped.errorDetails,
+    googleStatus: stamped.geminiStatus,
+    message: stamped.message,
+  });
 }
 
 // CC-rule safety stamp for Gemini stream failures (provider-stall audit):
@@ -225,7 +233,10 @@ export function geminiChunkProgressKind(chunk) {
  * (same shape as a non-streaming generateContent JSON body).
  * Mirrors @google/generative-ai aggregateResponses().
  */
-function aggregateGeminiStreamChunks(responses) {
+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,
@@ -270,11 +281,28 @@ function aggregateGeminiStreamChunks(responses) {
   return aggregatedResponse;
 }
 
-function assertGeminiStreamCompleted({ sawStreamChunk, finishReason, promptBlockReason, label }) {
+// 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())
+  );
+}
+
+function assertGeminiStreamCompleted({
+  sawStreamChunk,
+  finishReason,
+  promptBlockReason,
+  label,
+  acceptEmptyNoFinish = false,
+  aggregated = null,
+}) {
   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;
     throw geminiTruncatedStreamError(`${label} truncated: no finishReason`);
   }
 }
@@ -436,7 +464,17 @@ function createLeakGuardFinalizer(textLeakGuard) {
 // aggregation, leak guard, watchdogs — stays shared.
 export async function consumeGeminiRestStreamResponse(
   response,
-  { signal, onStreamDelta, onTextDelta, textLeakGuard, label, unwrapChunk = null, onChunk = null, failureUsage = null }
+  {
+    signal,
+    onStreamDelta,
+    onTextDelta,
+    textLeakGuard,
+    label,
+    unwrapChunk = null,
+    onChunk = null,
+    failureUsage = null,
+    acceptEmptyNoFinish = false,
+  }
 ) {
   const unwrap =
     typeof unwrapChunk === 'function'
@@ -464,7 +502,10 @@ export async function consumeGeminiRestStreamResponse(
   });
   // One decoded chunk: collected for aggregation and relayed to every sink.
   const relayChunk = (rawChunk) => {
+    // In-band errors stay top level even on a transport that nests payloads.
+    assertNoGeminiInBandError(rawChunk, label);
     const parsed = unwrap(rawChunk);
+    assertNoGeminiInBandError(parsed, label);
     if (!sawStreamChunk) {
       sawStreamChunk = true;
       watchdogs.clearFirstByte();
@@ -530,12 +571,13 @@ export async function consumeGeminiRestStreamResponse(
     }
     const tail = sseDataPayload(buffer.trim());
     if (tail) {
+      let rawTail;
       try {
-        const [rawTail] = await parseProviderJsonBatch([tail]);
-        relayChunk(rawTail);
+        [rawTail] = await parseProviderJsonBatch([tail]);
       } catch (cause) {
         throw geminiStreamCorruptionError(`${label} corrupt SSE tail JSON`, cause);
       }
+      relayChunk(rawTail);
     }
   } catch (err) {
     finalizeLeakGuard();
@@ -558,7 +600,7 @@ export async function consumeGeminiRestStreamResponse(
     finalizeLeakGuard();
   }
 
-  const aggregated = aggregateGeminiStreamChunks(allChunks);
+  const aggregated = aggregateGeminiStreamChunks(allChunks, label);
   const finishReason = aggregated.candidates?.[0]?.finishReason || null;
   const promptBlockReason = aggregated.promptFeedback?.blockReason || null;
   // Truncation (no finishReason) after visible output must carry the same
@@ -566,7 +608,14 @@ export async function consumeGeminiRestStreamResponse(
   // above, so stamp here too (review High: transient TRUNCATED_STREAM would
   // otherwise replay/double-render live text via withRetry).
   try {
-    assertGeminiStreamCompleted({ sawStreamChunk, finishReason, promptBlockReason, label });
+    assertGeminiStreamCompleted({
+      sawStreamChunk,
+      finishReason,
+      promptBlockReason,
+      label,
+      acceptEmptyNoFinish,
+      aggregated,
+    });
   } catch (err) {
     throw stampGeminiStreamFailure(err, { relayedText, textLeakGuard, chunks: allChunks, failureUsage });
   }
@@ -585,6 +634,7 @@ export async function consumeGeminiSdkStream(
     firstByteTimeoutMs = GEMINI_FIRST_BYTE_TIMEOUT_MS,
     cancellationGraceMs = 250,
     failureUsage = null,
+    acceptEmptyNoFinish = false,
   }
 ) {
   let relayedText = '';
@@ -636,6 +686,7 @@ export async function consumeGeminiSdkStream(
       if (signal?.aborted) throw abortError();
       if (step.done) break;
       reader.noteChunk();
+      assertNoGeminiInBandError(step.value, label);
       if (step.value) collectedChunks.push(step.value);
       try {
         onStreamDelta?.(geminiChunkProgressKind(step.value));
@@ -652,7 +703,7 @@ export async function consumeGeminiSdkStream(
     // locally; retain the SDK response path only for an empty collection.
     let raw;
     if (collectedChunks.length > 0) {
-      raw = aggregateGeminiStreamChunks(collectedChunks);
+      raw = aggregateGeminiStreamChunks(collectedChunks, label);
     } else {
       let response;
       try {
@@ -661,10 +712,18 @@ export async function consumeGeminiSdkStream(
         throw normalizeGeminiSdkError(err, label);
       }
       raw = response?.candidates ? response : response?.response || response;
+      assertNoGeminiInBandError(raw, label);
     }
     const finishReason = raw?.candidates?.[0]?.finishReason || null;
     const promptBlockReason = raw?.promptFeedback?.blockReason || null;
-    assertGeminiStreamCompleted({ sawStreamChunk: reader.sawStreamChunk, finishReason, promptBlockReason, label });
+    assertGeminiStreamCompleted({
+      sawStreamChunk: reader.sawStreamChunk,
+      finishReason,
+      promptBlockReason,
+      label,
+      acceptEmptyNoFinish,
+      aggregated: raw,
+    });
     return raw;
   } catch (err) {
     reader?.clearFirstByte();

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

@@ -1,9 +1,26 @@
+import { getModelMetadataSync } from '../../../shared/llm/model-catalog.mjs';
+
+// The thinkingLevel values the Gemini wire accepts.
 const LEVELS = ['minimal', 'low', 'medium', 'high'];
 
+// The thinkingLevel values the catalogs declare for the model (provider live
+// roster, then models.dev / LiteLLM rows, resolved by getModelMetadataSync),
+// limited to what the Gemini wire accepts. null when no catalog declares a ladder.
+function catalogThinkingLevels(model, provider) {
+  const bare = String(model || '').replace(/^models\//i, '');
+  const effort = getModelMetadataSync(bare, provider)?.reasoningOptions?.find((option) => option?.type === 'effort');
+  const declared = (Array.isArray(effort?.values) ? effort.values : [])
+    .map((value) => String(value).toLowerCase())
+    .filter((value) => LEVELS.includes(value));
+  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.
-export function geminiThinkingConfig(model, opts = {}, { includeThoughts } = {}) {
-  const id = String(model || '').toLowerCase();
+// 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.
+export function geminiThinkingConfig(model, opts = {}, { includeThoughts, provider = 'gemini' } = {}) {
   const rawBudget = opts.thinkingBudget ?? opts.thinkingBudgetTokens;
   const hasBudget = rawBudget !== undefined && rawBudget !== null && rawBudget !== '';
   const rawLevel = opts.thinkingLevel ?? (hasBudget ? undefined : opts.effort);
@@ -15,14 +32,7 @@ export function geminiThinkingConfig(model, opts = {}, { includeThoughts } = {})
     throw new TypeError('Choose thinkingLevel/effort or thinkingBudget, not both.');
   }
   if (level) {
-    if (!/^gemini-3(?:[.-]|$)/.test(id)) {
-      throw new TypeError(`${model} uses thinkingBudget instead of thinkingLevel/effort.`);
-    }
-    let supported = LEVELS;
-    if (/^gemini-3(?:\.0)?-pro(?:-|$)/.test(id)) supported = ['low', 'high'];
-    else if (/^gemini-3\.1-pro(?:-|$)/.test(id) || /^gemini-3\.[78]-flash(?:-|$)/.test(id)) {
-      supported = ['low', 'medium', 'high'];
-    } else if (/^gemini-3\.1-flash-lite.*image/.test(id)) supported = ['minimal', 'high'];
+    const supported = catalogThinkingLevels(model, provider) ?? LEVELS;
     if (!supported.includes(level)) {
       throw new TypeError(`${model} supports thinking levels ${supported.join(', ')}; received ${level}.`);
     }
@@ -33,15 +43,6 @@ export function geminiThinkingConfig(model, opts = {}, { includeThoughts } = {})
     if (!Number.isInteger(budget) || budget < -1) {
       throw new TypeError('thinkingBudget must be -1 (dynamic), 0, or a positive integer.');
     }
-    if (/^gemini-2\.5-pro(?:-|$)/.test(id) && budget !== -1 && (budget < 128 || budget > 32768)) {
-      throw new TypeError(`${model} requires thinkingBudget -1 or 128..32768.`);
-    }
-    if (/^gemini-2\.5-flash(?:-|$)/.test(id) && budget > 24576) {
-      throw new TypeError(`${model} requires thinkingBudget at most 24576.`);
-    }
-    if (/^gemini-2\.5-flash-lite(?:-|$)/.test(id) && budget > 0 && budget < 512) {
-      throw new TypeError(`${model} requires thinkingBudget -1, 0, or 512..24576.`);
-    }
     config.thinkingBudget = budget;
   }
   return Object.keys(config).length ? config : undefined;