mixdog 1.2.2 → 1.2.3

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

@@ -279,7 +279,7 @@ function _stripResponseItemsFromHead(items, responseItems) {
 // Official OpenAI Responses WebSocket guide: response.create WS frames mirror
 // the Responses body EXCEPT the transport-only fields `stream`/`background`,
 // which the socket carries implicitly and the guide says to omit. This set is
-// stripped from a frame (any build shape) only when omitTransportFields is on.
+// always stripped from a frame (any build shape).
 const TRANSPORT_ONLY_FRAME_FIELDS = new Set(['stream', 'background']);
 
 // Canonical response.create frame builder. Every WS send (main full-frame
@@ -293,14 +293,12 @@ const TRANSPORT_ONLY_FRAME_FIELDS = new Set(['stream', 'background']);
 // response, so dropping them here strips the system/lead prompt from every
 // continuation turn. Only an empty instructions string is omitted.
 // Full frames pass the body unchanged and keep every key in place.
-// omitTransportFields is used by wire-parity helpers to drop stream/background.
 export function _buildResponseCreateFrame(
   body,
-  { previousResponseId = null, inputOverride, omitTransportFields = false } = {}
+  { previousResponseId = null, inputOverride } = {}
 ) {
   const src = body && typeof body === 'object' ? body : {};
   if (previousResponseId == null && inputOverride === undefined) {
-    if (!omitTransportFields) return { type: 'response.create', ...src };
     const frame = { type: 'response.create' };
     for (const key of Object.keys(src)) {
       if (TRANSPORT_ONLY_FRAME_FIELDS.has(key)) continue;
@@ -310,7 +308,7 @@ export function _buildResponseCreateFrame(
   }
   const frame = { type: 'response.create' };
   for (const key of Object.keys(src)) {
-    if (omitTransportFields && TRANSPORT_ONLY_FRAME_FIELDS.has(key)) continue;
+    if (TRANSPORT_ONLY_FRAME_FIELDS.has(key)) continue;
     if (key === 'instructions') {
       const instr = src.instructions;
       if (typeof instr === 'string' && instr.length) frame.instructions = instr;
@@ -366,17 +364,10 @@ export function _computeDelta({ entry, body, traceProvider }) {
   if (!entry?.lastRequestSansInput || !entry.lastResponseId) {
     return { mode: 'full', reason: 'no_anchor', frame: buildFrame(body) };
   }
-  // Public OpenAI resolves previous_response_id out of its response STORE, so
-  // an anchor only exists when the anchored response was stored. store:false
-  // there — e.g. an explicit MIXDOG_OAI_STORE=0 opt-out on the openai-direct
-  // provider — makes a continuation frame fail with
-  // previous_response_not_found, so the opt-out degrades to full frames.
-  // openai-oauth/Codex (per-WS-session server state) and xAI (in-connection
-  // ZDR continuation with encrypted reasoning) both anchor without the store
-  // and are deliberately excluded from this gate.
-  if (traceProvider === 'openai-direct' && body?.store !== true) {
-    return { mode: 'full', reason: 'store_disabled', frame: buildFrame(body) };
-  }
+  // WebSocket mode keeps the latest response in a connection-local cache, so
+  // previous_response_id continues on the same socket even with store:false.
+  // If the server no longer has the anchor (previous_response_not_found), the
+  // caller recovers with a full-context frame.
   if (!deltaForce && !deltaRefs && !entry.turnState) {
     return { mode: 'full', reason: 'delta_missing_turn_state', frame: buildFrame(body) };
   }

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

@@ -0,0 +1,60 @@
+// Refusal content of one Responses stream. The model's refusal arrives as
+// `response.refusal.delta` / `response.refusal.done` and as a
+// `{type:'refusal', refusal}` content part of the message item
+// (output_item.done and the terminal output bundle). Parts are keyed by item
+// id + content index so the streamed, item-done and terminal copies of one
+// part fold into one text; a full (done / final-part) text replaces the
+// accumulated deltas. Shared by the WS and HTTP/SSE collectors.
+export function createRefusals() {
+  const parts = new Map();
+  const keyOf = (itemId, contentIndex) => `${itemId || ''}:${Number.isInteger(contentIndex) ? contentIndex : 0}`;
+
+  return {
+    /** response.refusal.delta */
+    delta(event) {
+      if (typeof event?.delta !== 'string') return;
+      const key = keyOf(event.item_id, event.content_index);
+      parts.set(key, (parts.get(key) || '') + event.delta);
+    },
+    /** response.refusal.done */
+    done(event) {
+      if (typeof event?.refusal !== 'string') return;
+      parts.set(keyOf(event.item_id, event.content_index), event.refusal);
+    },
+    /** A message item's refusal parts. Returns whether it carried any. */
+    absorbMessage(item) {
+      if (item?.type !== 'message' || !Array.isArray(item.content)) return false;
+      let found = false;
+      item.content.forEach((part, index) => {
+        if (part?.type !== 'refusal' || typeof part.refusal !== 'string') return;
+        found = true;
+        // An id-less item cannot be matched to its streamed copy; the
+        // streamed text already stands for it.
+        if (!item.id && parts.size > 0) return;
+        parts.set(keyOf(item.id, index), part.refusal);
+      });
+      return found;
+    },
+    get seen() {
+      return parts.size > 0;
+    },
+    get text() {
+      return [...parts.values()].filter(Boolean).join('\n');
+    },
+  };
+}
+
+/** The typed stop reason of a refused turn (read by the agent loop). */
+export const REFUSAL_STOP_REASON = 'refusal';
+
+/** Result fields for a refused turn — the shared result shape:
+ *    stopReason: REFUSAL_STOP_REASON
+ *    refusal:    the refusal text (joined parts; may be '')
+ *    content:    the output_text, or the refusal text when there was none
+ *  so a refusal never reads as an empty successful answer. Empty object when
+ *  the response carried no refusal. */
+export function refusalResultFields(refusals, content) {
+  if (!refusals.seen) return {};
+  const refusal = refusals.text;
+  return { content: content || refusal, refusal, stopReason: REFUSAL_STOP_REASON };
+}

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,20 +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() {
@@ -238,6 +248,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

@@ -111,6 +111,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 +143,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
@@ -228,7 +233,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);
     }

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

@@ -0,0 +1,170 @@
+/**
+ * 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();
+    }
+  }
+}