mixdog 1.2.2 → 1.2.4

package/src/runtime/agent/orchestrator/providers/openai-ws-response-state/tool-calls.mjs

@@ -1,7 +1,12 @@
 import { makeInvalidToolArgsMarker } from '../lib/openai-tool-args.mjs';
 import { synthLeakedOpenAICall } from '../openai-compat-stream-common.mjs';
 import { createToolCallDedupe, dedupeToolCallList } from '../lib/leaked-toolcall.mjs';
-import { customToolCallFromResponseItem, nativeToolSearchCallFromArguments } from '../custom-tool-wire.mjs';
+import {
+  customToolCallFromResponseItem,
+  nativeToolSearchCallFromArguments,
+  qualifiedToolCallName,
+  withToolCallNamespace,
+} from '../custom-tool-wire.mjs';
 import { createActiveToolItemTracker } from '../tool-stream-state.mjs';
 
 // tool_search_call.arguments parse. Module-scope (exported) for direct test
@@ -64,7 +69,7 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
     } catch {}
   }
   function emit(call) {
-    if (!toolDedupe.shouldDispatch(call?.name, call?.arguments, call?.id)) return;
+    if (!toolDedupe.shouldDispatch(qualifiedToolCallName(call), call?.arguments, call?.id)) return;
     fire(call);
   }
   function settle() {
@@ -84,6 +89,8 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
   }
   function pushToolSearchCall(item) {
     if (item?.type !== 'tool_search_call') return;
+    // Server-executed search already ran inside the response; replay-only.
+    if (item.execution === 'server') return;
     const callId = item.call_id || item.id || '';
     if (!callId || toolCalls.some((call) => call.id === callId)) return;
     const call = nativeToolSearchCallFromArguments(callId, parseToolSearchArgs(item.arguments));
@@ -106,7 +113,10 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
     const type = item?.type;
     if (type === 'function_call') {
       markStarted(item);
-      pendingCalls.set(item.id || '', { name: item.name || '', callId: item.call_id || '' });
+      pendingCalls.set(
+        item.id || '',
+        withToolCallNamespace({ name: item.name || '', callId: item.call_id || '' }, item)
+      );
     } else if (type === 'custom_tool_call' || type === 'tool_search_call') {
       // tool_search is marked in-flight at item-added time too, so the
       // semantic-idle stall gate's pendingToolUse never drops a mid-flight
@@ -134,7 +144,7 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
       argumentsText: event.arguments || JSON.stringify(args),
     });
     if (pending?.callId && pending?.name) {
-      const call = { id: pending.callId, name: pending.name, arguments: args };
+      const call = withToolCallNamespace({ id: pending.callId, name: pending.name, arguments: args }, pending);
       toolCalls.push(call);
       emit(call);
       pendingCalls.delete(itemId);
@@ -150,31 +160,45 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
     // bundle. If salvage also fails the stream fails explicitly — masking the
     // gap with a synthetic id just shifts the failure one turn later under a
     // confusing "No tool output found for function call" error.
-    toolCalls.push({
-      id: pending?.callId || '',
-      name: pending?.name || '',
-      arguments: args,
-      _pendingItemId: itemId,
-      _deferred: true,
-    });
+    toolCalls.push(
+      withToolCallNamespace(
+        {
+          id: pending?.callId || '',
+          name: pending?.name || '',
+          arguments: args,
+          _pendingItemId: itemId,
+          _deferred: true,
+        },
+        pending
+      )
+    );
   }
 
-  /** response.output_item.done for a function_call item */
+  /** A complete function_call item (output_item.done, or the terminal
+   *  response output bundle) through the one deduplicated collector: it
+   *  resolves the deferred placeholder for its item (canonical call_id/name
+   *  from the item, missing ones kept from the placeholder), is skipped when
+   *  its call_id is already recorded, and is otherwise created and
+   *  dispatched — so a call present only in the terminal bundle still runs. */
   function completeFunctionCallItem(item) {
     const itemId = item.id || '';
     const callId = item.call_id || '';
     const name = item.name || '';
     const args = parseFunctionCallArgs(argsTextOf(item.arguments));
     const deferred = toolCalls.find((tc) => tc?._deferred && (!itemId || tc._pendingItemId === itemId));
-    if (deferred && callId && name) {
-      deferred.id = callId;
-      deferred.name = name;
-      deferred.arguments = deferred.arguments && Object.keys(deferred.arguments).length > 0 ? deferred.arguments : args;
-      delete deferred._deferred;
-      delete deferred._pendingItemId;
-      emit(deferred);
+    if (deferred) {
+      deferred.id = callId || deferred.id;
+      deferred.name = name || deferred.name;
+      withToolCallNamespace(deferred, item);
+      if (deferred.id && deferred.name) {
+        deferred.arguments =
+          deferred.arguments && Object.keys(deferred.arguments).length > 0 ? deferred.arguments : args;
+        delete deferred._deferred;
+        delete deferred._pendingItemId;
+        emit(deferred);
+      }
     } else if (callId && name && !toolCalls.some((tc) => tc?.id === callId)) {
-      const call = { id: callId, name, arguments: args };
+      const call = withToolCallNamespace({ id: callId, name, arguments: args }, item);
       toolCalls.push(call);
       emit(call);
     }
@@ -193,21 +217,6 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
     settle();
   }
 
-  /** response.completed salvage: when arguments.done fired before (or
-   *  without) a matching output_item.added, the deferred placeholder has an
-   *  empty id/name; the bundle carries the canonical call_id/name. */
-  function salvageFunctionCall(item) {
-    const tc = toolCalls.find((t) => t._deferred && t._pendingItemId === (item.id || ''));
-    if (!tc) return;
-    if (!tc.id && item.call_id) tc.id = item.call_id;
-    if (!tc.name && item.name) tc.name = item.name;
-    if (tc.id && tc.name) {
-      delete tc._deferred;
-      delete tc._pendingItemId;
-      emit(tc);
-    }
-  }
-
   return {
     get calls() {
       return toolCalls;
@@ -238,6 +247,12 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
     completeFunctionCallItem,
     completeToolSearchItem,
     completeCustomToolItem,
-    salvageFunctionCall,
+    /** A server-truncated call item: kept in flight, never collected. */
+    holdIncompleteItem: markStarted,
+    // Terminal-bundle salvage (response.completed / success response.done):
+    // the same collector as output_item.done. When arguments.done fired
+    // before (or without) output_item.added, the deferred placeholder has an
+    // empty id/name and the bundle carries the canonical call_id/name.
+    salvageFunctionCall: completeFunctionCallItem,
   };
 }

package/src/runtime/agent/orchestrator/providers/openai-ws-response-state.mjs

@@ -13,6 +13,8 @@ import { createReplayItems } from './openai-ws-response-state/replay-items.mjs';
 import { createCitations } from './openai-ws-response-state/citations.mjs';
 import { createWsToolCalls } from './openai-ws-response-state/tool-calls.mjs';
 import { normalizeWsUsage } from './openai-ws-response-state/usage.mjs';
+import { createRefusals, refusalResultFields } from './openai-ws-response-state/refusals.mjs';
+import { isIncompleteToolItem } from './lib/responses-terminal-fields.mjs';
 
 export { parseToolSearchArgs } from './openai-ws-response-state/tool-calls.mjs';
 
@@ -37,6 +39,7 @@ export function createWsResponseState({ onToolCall, onStreamDelta, midState, tra
   const reasoningDeltas = { text: 0, summary: 0, other: 0 };
   const replayItems = createReplayItems();
   const citations = createCitations();
+  const refusals = createRefusals();
   const tools = createWsToolCalls({ onToolCall, midState, replayItems });
   const replayProvider = traceProvider === 'xai' ? 'xai-responses' : 'openai-responses';
   const progress = (kind) => {
@@ -49,6 +52,11 @@ export function createWsResponseState({ onToolCall, onStreamDelta, midState, tra
   // anything the per-item events never carried. Returns whether any progress
   // was reported.
   function salvageCompletedItem(item, relayFinalText) {
+    if (isIncompleteToolItem(item)) {
+      tools.holdIncompleteItem(item);
+      progress('tool');
+      return true;
+    }
     replayItems.push(item);
     let reported = false;
     if (item.type === 'message') {
@@ -64,6 +72,10 @@ export function createWsResponseState({ onToolCall, onStreamDelta, midState, tra
         }
         citations.pushOutputTextAnnotations(c);
       }
+      if (refusals.absorbMessage(item)) {
+        progress('semantic');
+        reported = true;
+      }
     }
     if (item.type === 'web_search_call') {
       citations.pushWebSearchCall(item);
@@ -146,10 +158,19 @@ export function createWsResponseState({ onToolCall, onStreamDelta, midState, tra
     noteToolInputDelta: tools.noteToolInputDelta,
     /** response.function_call_arguments.done */
     completeFunctionCallArguments: tools.completeFunctionCallArguments,
+    /** response.refusal.delta */
+    noteRefusalDelta: refusals.delta,
+    /** response.refusal.done */
+    noteRefusalDone: refusals.done,
     /** response.output_item.done. Returns the progress kind to report. */
     completeOutputItem(item) {
+      if (isIncompleteToolItem(item)) {
+        tools.holdIncompleteItem(item);
+        return 'tool';
+      }
       replayItems.push(item);
       const type = item?.type || '';
+      if (type === 'message') refusals.absorbMessage(item);
       // function_call / output_text already arrive via their dedicated
       // streaming events; `reasoning` carries encrypted_content that keeps the
       // openai-oauth server-side prompt cache prefix warm.
@@ -189,6 +210,13 @@ export function createWsResponseState({ onToolCall, onStreamDelta, midState, tra
       if (!responseId && response?.id) responseId = response.id;
       return usage;
     },
+    /** A cutoff frame's output bundle: call items the server truncated stay
+     *  in flight so the cutoff reads as a pending-tool turn. */
+    holdIncompleteBundleItems(response) {
+      for (const item of response?.output || []) {
+        if (isIncompleteToolItem(item)) tools.holdIncompleteItem(item);
+      }
+    },
     /** max_output_tokens maps cleanly to Anthropic's stop_reason=max_tokens. */
     markMaxOutputIncomplete(reason) {
       incompleteReason = reason;
@@ -227,6 +255,8 @@ export function createWsResponseState({ onToolCall, onStreamDelta, midState, tra
         ...(typeof endTurn === 'boolean' ? { endTurn } : {}),
         responseId: responseId || undefined,
         serviceTier: responseServiceTier || undefined,
+        // A refused turn: typed stop reason and the refusal text.
+        ...refusalResultFields(refusals, content),
       };
     },
   };

package/src/runtime/agent/orchestrator/providers/openai-ws-stream/event-switch.mjs

@@ -88,6 +88,18 @@ export function createWsEventSwitch({ response, textRelay, watchdogs, midState,
         progress('tool');
         watchdogs.bumpSemantic();
         break;
+      // Refusal text is model output but never visible answer text: it is
+      // collected for the typed refusal result, not relayed live.
+      case 'response.refusal.delta':
+        response.noteRefusalDelta(event);
+        progress('semantic');
+        watchdogs.bumpSemantic();
+        break;
+      case 'response.refusal.done':
+        response.noteRefusalDone(event);
+        progress('semantic');
+        watchdogs.bumpSemantic();
+        break;
       case 'response.output_item.done': {
         const kind = response.completeOutputItem(event.item);
         // Item-done is genuine lifecycle progress — reset semantic idle so

package/src/runtime/agent/orchestrator/providers/openai-ws-stream/terminal-frames.mjs

@@ -27,11 +27,30 @@ export function createTerminalFrameHandlers({ response, textRelay, midState, err
 
   // Most incomplete reasons are real failures. max_output_tokens maps cleanly
   // to Anthropic's stop_reason=max_tokens; treating it as an error makes
-  // Claude retry the same over-budget turn.
+  // Claude retry the same over-budget turn — unless a tool call's input was
+  // still streaming: its arguments were truncated, so the cutoff is a
+  // stalled pending-tool turn (same guard as HTTP/SSE), never a clean length
+  // completion that would surface the partial call as successful.
   function settleIncomplete(event, label, options) {
     const usage = response.noteTerminal(event.response);
     const reasonStr = _incompleteReasonFromEvent(event);
     if (_isMaxOutputIncompleteReason(reasonStr)) {
+      response.holdIncompleteBundleItems(event.response);
+      if (response.pendingToolUse) {
+        const error = new Error(`${label} (max_output_tokens) with tool call in flight`);
+        try {
+          textRelay.flush();
+        } catch {
+          /* best-effort */
+        }
+        Object.assign(error, response.partialState());
+        error.streamStalled = true;
+        error.pendingToolUse = true;
+        error.incompleteReason = reasonStr;
+        if (usage) error.partialUsage = usage;
+        failWith(error, options);
+        return;
+      }
       response.markMaxOutputIncomplete(reasonStr);
       completeTurn();
       return;
@@ -105,11 +124,11 @@ export function createTerminalFrameHandlers({ response, textRelay, midState, err
       failWith(responseDoneStatusError(status, `${errLabel} response.done unexpected status`), { markDone: true });
       return;
     }
-    // Success-shaped response.done (status '' or 'completed') carries the
-    // same optional end_turn, and the response's usage.
-    response.noteTerminal(event.response);
-    response.setEndTurn(_endTurnFromEvent(event));
-    completeTurn();
+    // Success-shaped response.done (status '' or 'completed') is the same
+    // terminal as response.completed: usage, end_turn, and its output bundle
+    // reconciled through the same deduplicated collectors (calls that appear
+    // only in the bundle are created; unresolvable deferred calls fail).
+    onResponseCompleted(event);
   }
 
   function onResponseIncomplete(event) {

package/src/runtime/agent/orchestrator/providers/openai-ws.mjs

@@ -29,10 +29,13 @@ import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { noteRequestServiceTier } from '../../../shared/llm/usage-context.mjs';
 import { resolveProviderCacheKey, resolveProviderPromptCacheLane } from '../agent-runtime/cache-strategy.mjs';
 
+function isUnsafeToRetry(err) {
+  return err?.liveTextEmitted === true || err?.emittedToolCall === true || err?.unsafeToRetry === true;
+}
+
 function shouldFallbackDirectTransport(err, options) {
   const status = Number(err?.httpStatus || err?.status || 0);
-  const unsafeToRetry = err?.liveTextEmitted === true || err?.emittedToolCall === true || err?.unsafeToRetry === true;
-  if (unsafeToRetry || options?.signal?.aborted || options?.enabled === false) return false;
+  if (isUnsafeToRetry(err) || options?.signal?.aborted || options?.enabled === false) return false;
   // Public OpenAI can reject the WebSocket upgrade while still supporting
   // the same request over HTTP/SSE. Only the shared transport's explicit
   // handshake marker may turn these application-looking statuses into a
@@ -111,6 +114,10 @@ export class OpenAIDirectProvider {
     }
     return null;
   }
+  /** Drop a disposed transport scope's sticky transport record. */
+  releaseTransportScope(scope) {
+    this._httpFallbackPoolKeys.delete(scope);
+  }
   send(messages, model, tools, sendOpts) {
     return withEffortConfigurationFallback('openai', model, sendOpts || {}, (opts) =>
       this._sendOnce(messages, model, tools, opts)
@@ -139,8 +146,9 @@ export class OpenAIDirectProvider {
     // poolKey MUST be sessionId-only. Falling back to promptCacheKey would
     // let unrelated raw sessions sharing the same provider-scoped cache
     // bucket reuse each other's pooled socket and inherit lastResponseId
-    // delta state, producing cross-session prompt corruption.
-    const poolKey = opts.sessionId || null;
+    // delta state, producing cross-session prompt corruption. A forked
+    // request runs in its own transport scope (transport-scope.mjs).
+    const poolKey = opts.transportScope || opts.sessionId || null;
     // cacheKey (prompt_cache_key) only groups the server-side prefix-cache
     // shard — safe to share across sessions, unlike the sessionId poolKey
     // above. buildRequestBody derives it from the base namespace plus a
@@ -200,8 +208,7 @@ export class OpenAIDirectProvider {
       try {
         return await sendHttp({ ...common, auth: a, opts, fetchFn: opts._fetchFn });
       } catch (err) {
-        const unsafe = err?.liveTextEmitted === true || err?.emittedToolCall === true || err?.unsafeToRetry === true;
-        if (!reload || err?.httpStatus !== 401 || unsafe) throw err;
+        if (!reload || err?.httpStatus !== 401 || isUnsafeToRetry(err)) throw err;
         // The replay discards this attempt; its reported usage stays billed.
         noteErrorUsage(err);
         process.stderr.write('[openai-ws] 401 — reloading apiKey and retrying once over HTTP\n');
@@ -228,7 +235,10 @@ export class OpenAIDirectProvider {
     // ws-delta only affects the delta gate inside openai-ws-delta.mjs.
     if (
       transportPolicy.transport === 'http' ||
-      (poolKey && httpFallbackEnabled && this._httpFallbackPoolKeys.has(poolKey))
+      (poolKey &&
+        httpFallbackEnabled &&
+        // A forked scope follows its session's refusal; it records its own.
+        (this._httpFallbackPoolKeys.has(poolKey) || this._httpFallbackPoolKeys.has(opts.sessionId)))
     ) {
       return await sendHttpWithKeyReload(auth);
     }
@@ -244,8 +254,7 @@ export class OpenAIDirectProvider {
       const status = err?.httpStatus;
       // Live-text/tool invariant: never reissue a turn that already
       // relayed visible output or dispatched a tool call.
-      const unsafeToRetry =
-        err?.liveTextEmitted === true || err?.emittedToolCall === true || err?.unsafeToRetry === true;
+      const unsafeToRetry = isUnsafeToRetry(err);
       // (1) 401 → reload only OpenAI auth and retry once over WS.
       // Ordinary 403 is a permission/policy decision, not evidence that
       // an API key rotated. Match the OAuth path and keep it terminal.

package/src/runtime/agent/orchestrator/providers/opencode-go-gemini.mjs

@@ -0,0 +1,181 @@
+/**
+ * OpenCode Go's Gemini route: `@ai-sdk/google` models are served by the
+ * gateway's generateContent endpoint, `{base}/models/{id}:streamGenerateContent`
+ * (https://opencode.ai/docs/go/ — Endpoints table). This engine reuses the
+ * direct Gemini adapter's request builder, stream consumer, retry ladder and
+ * result shaping, and only moves the transport onto the gateway: the Go key
+ * (never GEMINI_API_KEY) goes to the Go origin only, as a bearer token and the
+ * `x-goog-api-key` header, with the session / User-Agent headers of every Go
+ * request. Gateway models have no explicit cachedContents.
+ */
+import { GeminiProvider, geminiRestError } from './gemini.mjs';
+import { GEMINI_FIRST_BYTE_TIMEOUT_MS, consumeGeminiRestStreamResponse } from './gemini-stream.mjs';
+import { geminiBareModelId } from './gemini-cache-policy.mjs';
+import { geminiFailureUsage } from './gemini-response.mjs';
+import { geminiEndsWithFunctionResponse, runGeminiStreamAttempts } from './gemini-retry-policy.mjs';
+import { geminiTextLeakGuardFor } from './gemini-sdk-request.mjs';
+import { emitProviderRetryStage } from './retry-classifier.mjs';
+import { originBoundFetch } from './lib/origin-bound-fetch.mjs';
+import { createPassthroughSignal, createTimeoutSignal } from '../stall-policy.mjs';
+import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
+import { reloadProviderApiKey, resolveProviderApiKey } from '../../../shared/provider-api-key.mjs';
+
+const PROVIDER = 'opencode-go';
+
+/** The generateContent request body for a built Gemini request. */
+export function openCodeGoGeminiBody({
+  contents,
+  systemInstruction,
+  geminiTools,
+  toolConfig,
+  generationConfig,
+  safetySettings,
+}) {
+  return {
+    contents,
+    ...(systemInstruction ? { systemInstruction: { parts: [{ text: systemInstruction }] } } : {}),
+    ...(geminiTools ? { tools: geminiTools } : {}),
+    ...(toolConfig ? { toolConfig } : {}),
+    ...(generationConfig ? { generationConfig } : {}),
+    ...(safetySettings ? { safetySettings } : {}),
+  };
+}
+
+export class OpenCodeGoGeminiEngine extends GeminiProvider {
+  name = PROVIDER;
+
+  /** @param {object} config  the Go provider config; `baseURL` is the OpenAI-style `.../v1` base */
+  constructor(config) {
+    const base = String(config.baseURL || '').replace(/\/+$/, '');
+    super({
+      ...config,
+      fetchFn: originBoundFetch(new URL(base).origin, config.fetchImpl, PROVIDER),
+      // No Google host to warm and no Google SDK client: this engine never uses either.
+      preconnectFn: () => {},
+      createGenAI: () => null,
+    });
+    this.gatewayBase = base;
+  }
+
+  _getApiKey() {
+    return resolveProviderApiKey(PROVIDER, this.config);
+  }
+
+  reloadApiKey() {
+    const key = reloadProviderApiKey(PROVIDER, this.config);
+    if (key) this.config = { ...(this.config || {}), apiKey: key };
+    return key || '';
+  }
+
+  async isAvailable() {
+    return Boolean(this._getApiKey());
+  }
+
+  // The gateway has no cachedContents resource.
+  async _ensureGeminiCache() {
+    return null;
+  }
+
+  _headers(opts) {
+    const key = this._getApiKey();
+    return {
+      'Content-Type': 'application/json',
+      ...(key ? { Authorization: `Bearer ${key}`, 'x-goog-api-key': key } : {}),
+      ...(this.config?.extraHeaders || {}),
+      ...(opts?.requestHeaders || {}),
+    };
+  }
+
+  _url(model, method) {
+    return `${this.gatewayBase}/models/${encodeURIComponent(geminiBareModelId(model))}:${method}`;
+  }
+
+  async _openGatewayStream(url, body, opts, attemptSignal) {
+    const openFirstByte = createTimeoutSignal(
+      attemptSignal,
+      GEMINI_FIRST_BYTE_TIMEOUT_MS,
+      'OpenCode Go Gemini first byte'
+    );
+    let res;
+    try {
+      res = await this._fetch(url, {
+        method: 'POST',
+        headers: this._headers(opts),
+        body: JSON.stringify(body),
+        signal: openFirstByte.signal,
+        dispatcher: getLlmDispatcher(),
+      });
+    } finally {
+      openFirstByte.cleanup();
+    }
+    if (!res.ok) {
+      throw geminiRestError(res, await res.text().catch(() => ''), 'OpenCode Go Gemini streamGenerateContent');
+    }
+    return res;
+  }
+
+  async _generateContent(model, body, opts, signal) {
+    const res = await this._fetch(this._url(model, 'generateContent'), {
+      method: 'POST',
+      headers: this._headers(opts),
+      body: JSON.stringify(body),
+      signal,
+      dispatcher: getLlmDispatcher(),
+    });
+    if (!res.ok) {
+      throw geminiRestError(res, await res.text().catch(() => ''), 'OpenCode Go Gemini generateContent');
+    }
+    return await res.json();
+  }
+
+  async _streamViaSdk(stream) {
+    const { opts, signal, useModel, contents, callbacks } = stream;
+    const body = openCodeGoGeminiBody(stream);
+    const url = `${this._url(useModel, 'streamGenerateContent')}?alt=sse`;
+    const passthrough = createPassthroughSignal(signal);
+    try {
+      return await runGeminiStreamAttempts({
+        signal: passthrough.signal,
+        sleepFn: this.config?.sleepFn,
+        onRetry: ({ attempt, maxAttempts, lastErr, delayMs }) => {
+          emitProviderRetryStage(opts.onStageChange, { attempt: attempt + 1, maxAttempts, lastErr, delayMs });
+          process.stderr.write(
+            `[opencode-go:gemini] retry attempt ${attempt + 1} after ${lastErr?.message || lastErr?.code || 'transient error'}\n`
+          );
+        },
+        afterToolResult: geminiEndsWithFunctionResponse(contents),
+        run: async ({ signal: attemptSignal, connected }) => {
+          try {
+            opts.onStageChange?.('requesting');
+          } catch {
+            /* heartbeat best-effort */
+          }
+          const res = await this._openGatewayStream(url, body, opts, attemptSignal);
+          connected();
+          const textLeakGuard = geminiTextLeakGuardFor(stream);
+          const response = await consumeGeminiRestStreamResponse(res, {
+            signal: attemptSignal,
+            onStreamDelta: callbacks.onStreamDelta,
+            onTextDelta: callbacks.onTextDelta,
+            textLeakGuard,
+            label: 'OpenCode Go Gemini streamGenerateContent',
+            failureUsage: geminiFailureUsage(opts, null, useModel),
+          });
+          return { response, textLeakGuard };
+        },
+      });
+    } catch (err) {
+      const recovered = await this._recoverGeminiNonStreaming({
+        streamErr: err,
+        signal: passthrough.signal,
+        opts,
+        model: useModel,
+        generate: (fallbackSignal) => this._generateContent(useModel, body, opts, fallbackSignal),
+      });
+      if (!recovered) throw err;
+      return { response: recovered, textLeakGuard: null };
+    } finally {
+      passthrough.cleanup();
+    }
+  }
+}