opencode-gemini-auth 1.3.7 → 1.3.8

package/README.md

@@ -15,7 +15,7 @@ directly within Opencode, bypassing separate API billing.
 ## Installation
 
 Add the plugin to your Opencode configuration file
-(`~/.config/opencode/config.json` or similar):
+(`~/.config/opencode/opencode.json` or similar):
 
 ```json
 {
@@ -60,19 +60,41 @@ project. To force a specific project, set the `projectId` in your configuration:
 }
 ```
 
-### Thinking Models
-
-Configure "thinking" capabilities for Gemini models using the `thinkingConfig`
-option in your `config.json`.
+### Model list
 
-**Gemini 3 (Thinking Level)**
-Use `thinkingLevel` (`"low"`, `"high"`) for Gemini 3 models.
+Below are example model entries you can add under `provider.google.models` in your
+Opencode config. Each model can include an `options.thinkingConfig` block to
+enable "thinking" features.
 
 ```json
 {
   "provider": {
     "google": {
       "models": {
+        "gemini-2.5-flash": {
+          "options": {
+            "thinkingConfig": {
+              "thinkingBudget": 8192,
+              "includeThoughts": true
+            }
+          }
+        },
+        "gemini-2.5-pro": {
+          "options": {
+            "thinkingConfig": {
+              "thinkingBudget": 8192,
+              "includeThoughts": true
+            }
+          }
+        },
+        "gemini-3-flash-preview": {
+          "options": {
+            "thinkingConfig": {
+              "thinkingLevel": "high",
+              "includeThoughts": true
+            }
+          }
+        },
         "gemini-3-pro-preview": {
           "options": {
             "thinkingConfig": {
@@ -87,14 +109,33 @@ Use `thinkingLevel` (`"low"`, `"high"`) for Gemini 3 models.
 }
 ```
 
-**Gemini 2.5 (Thinking Budget)**
-Use `thinkingBudget` (token count) for Gemini 2.5 models.
+Note: Available model names and previews may change—check Google's documentation or
+the Gemini product page for the current model identifiers.
+
+### Thinking Models
+
+The plugin supports configuring Gemini "thinking" features per-model via
+`thinkingConfig`. The available fields depend on the model family:
+
+- For Gemini 3 models: use `thinkingLevel` with values `"low"` or `"high"`.
+- For Gemini 2.5 models: use `thinkingBudget` (token count).
+- `includeThoughts` (boolean) controls whether the model emits internal thoughts.
+
+A combined example showing both model types:
 
 ```json
 {
   "provider": {
     "google": {
       "models": {
+        "gemini-3-pro-preview": {
+          "options": {
+            "thinkingConfig": {
+              "thinkingLevel": "high",
+              "includeThoughts": true
+            }
+          }
+        },
         "gemini-2.5-flash": {
           "options": {
             "thinkingConfig": {
@@ -109,6 +150,9 @@ Use `thinkingBudget` (token count) for Gemini 2.5 models.
 }
 ```
 
+If you don't set a `thinkingConfig` for a model, the plugin will use default
+behavior for that model.
+
 ## Troubleshooting
 
 ### Manual Google Cloud Setup

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-gemini-auth",
   "module": "index.ts",
-  "version": "1.3.7",
+  "version": "1.3.8",
   "author": "jenslys",
   "repository": "https://github.com/jenslys/opencode-gemini-auth",
   "files": [
@@ -11,7 +11,7 @@
   "license": "MIT",
   "type": "module",
   "devDependencies": {
-    "@opencode-ai/plugin": "^1.0.203",
+    "@opencode-ai/plugin": "^1.1.25",
     "@types/bun": "latest"
   },
   "peerDependencies": {

package/src/gemini/oauth.ts

@@ -90,6 +90,8 @@ export async function authorizeGemini(): Promise<GeminiAuthorization> {
   url.searchParams.set("state", encodeState({ verifier: pkce.verifier }));
   url.searchParams.set("access_type", "offline");
   url.searchParams.set("prompt", "consent");
+  // Add a fragment so any stray terminal glyphs are ignored by the auth server.
+  url.hash = "opencode";
 
   return {
     url: url.toString(),

package/src/plugin/request.ts

@@ -13,6 +13,137 @@ const STREAM_ACTION = "streamGenerateContent";
 const MODEL_FALLBACKS: Record<string, string> = {
   "gemini-2.5-flash-image": "gemini-2.5-flash",
 };
+
+interface GeminiFunctionCallPart {
+  functionCall?: {
+    name: string;
+    args?: Record<string, unknown>;
+    [key: string]: unknown;
+  };
+  thoughtSignature?: string;
+  [key: string]: unknown;
+}
+
+interface GeminiContentPart {
+  role?: string;
+  parts?: GeminiFunctionCallPart[];
+  [key: string]: unknown;
+}
+
+interface OpenAIToolCall {
+  id?: string;
+  type?: string;
+  function?: {
+    name?: string;
+    arguments?: string;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+
+interface OpenAIMessage {
+  role?: string;
+  content?: string | null;
+  tool_calls?: OpenAIToolCall[];
+  tool_call_id?: string;
+  name?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Transforms OpenAI tool_calls to Gemini functionCall format and adds thoughtSignature.
+ * This ensures compatibility when OpenCode sends OpenAI-format function calls.
+ */
+function transformOpenAIToolCalls(requestPayload: Record<string, unknown>): void {
+  const messages = requestPayload.messages;
+  if (!messages || !Array.isArray(messages)) {
+    return;
+  }
+
+  for (const message of messages) {
+    if (message && typeof message === "object") {
+      const msgObj = message as OpenAIMessage;
+      const toolCalls = msgObj.tool_calls;
+      if (toolCalls && Array.isArray(toolCalls) && toolCalls.length > 0) {
+        const parts: GeminiFunctionCallPart[] = [];
+
+        if (typeof msgObj.content === "string" && msgObj.content.length > 0) {
+          parts.push({ text: msgObj.content });
+        }
+
+        for (const toolCall of toolCalls) {
+          if (toolCall && typeof toolCall === "object") {
+            const functionObj = toolCall.function;
+            if (functionObj && typeof functionObj === "object") {
+              const name = functionObj.name;
+              const argsStr = functionObj.arguments;
+              let args: Record<string, unknown> = {};
+              if (typeof argsStr === "string") {
+                try {
+                  args = JSON.parse(argsStr) as Record<string, unknown>;
+                } catch {
+                  args = {};
+                }
+              }
+
+              parts.push({
+                functionCall: {
+                  name: name ?? "",
+                  args,
+                },
+                thoughtSignature: "skip_thought_signature_validator",
+              });
+            }
+          }
+        }
+
+        msgObj.parts = parts;
+        delete msgObj.tool_calls;
+        delete msgObj.content;
+      }
+    }
+  }
+}
+
+/**
+ * Adds thoughtSignature to function call parts in the request payload.
+ * Gemini 3+ models require thoughtSignature for function calls when using thinking capabilities.
+ * This must be applied to all content blocks in the conversation history.
+ * Handles both flat contents arrays and nested request.contents (wrapped bodies).
+ */
+function addThoughtSignaturesToFunctionCalls(requestPayload: Record<string, unknown>): void {
+  const processContents = (contents: unknown): void => {
+    if (!contents || !Array.isArray(contents)) {
+      return;
+    }
+
+    for (const content of contents) {
+      if (content && typeof content === "object") {
+        const contentObj = content as Record<string, unknown>;
+        const parts = contentObj.parts;
+        if (parts && Array.isArray(parts)) {
+          for (const part of parts) {
+            if (part && typeof part === "object") {
+              const partObj = part as Record<string, unknown>;
+              if (partObj.functionCall && !partObj.thoughtSignature) {
+                partObj.thoughtSignature = "skip_thought_signature_validator";
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+
+  processContents(requestPayload.contents);
+
+  const nestedRequest = requestPayload.request;
+  if (nestedRequest && typeof nestedRequest === "object") {
+    const requestObj = nestedRequest as Record<string, unknown>;
+    processContents(requestObj.contents);
+  }
+}
+
 /**
  * Detects Gemini/Generative Language API requests by URL.
  * @param input Request target passed to fetch.
@@ -155,6 +286,9 @@ export function prepareGeminiRequest(
       } else {
         const requestPayload: Record<string, unknown> = { ...parsedBody };
 
+        transformOpenAIToolCalls(requestPayload);
+        addThoughtSignaturesToFunctionCalls(requestPayload);
+
         const rawGenerationConfig = requestPayload.generationConfig as Record<string, unknown> | undefined;
         const normalizedThinking = normalizeThinkingConfig(rawGenerationConfig?.thinkingConfig);
         if (normalizedThinking) {

package/src/plugin.ts

@@ -126,7 +126,7 @@ export const GeminiCLIOAuthPlugin = async (
             projectId: projectContext.effectiveProjectId,
           });
 
-          const response = await fetch(request, transformedInit);
+          const response = await fetchWithRetry(request, transformedInit);
           return transformGeminiResponse(response, streaming, debugContext, requestedModel);
         },
       };
@@ -246,6 +246,11 @@ export const GeminiCLIOAuthPlugin = async (
 
 export const GoogleOAuthPlugin = GeminiCLIOAuthPlugin;
 
+const RETRYABLE_STATUS_CODES = new Set([429, 503]);
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_BASE_DELAY_MS = 800;
+const DEFAULT_MAX_DELAY_MS = 8000;
+
 function toUrlString(value: RequestInfo): string {
   if (typeof value === "string") {
     return value;
@@ -308,3 +313,198 @@ function openBrowserUrl(url: string): void {
   } catch {
   }
 }
+
+async function fetchWithRetry(input: RequestInfo, init: RequestInit | undefined): Promise<Response> {
+  const maxRetries = DEFAULT_MAX_RETRIES;
+  const baseDelayMs = DEFAULT_BASE_DELAY_MS;
+  const maxDelayMs = DEFAULT_MAX_DELAY_MS;
+
+  if (!canRetryRequest(init)) {
+    return fetch(input, init);
+  }
+
+  let attempt = 0;
+  while (true) {
+    const response = await fetch(input, init);
+    if (!RETRYABLE_STATUS_CODES.has(response.status) || attempt >= maxRetries) {
+      return response;
+    }
+
+    const delayMs = await getRetryDelayMs(response, attempt, baseDelayMs, maxDelayMs);
+    if (!delayMs || delayMs <= 0) {
+      return response;
+    }
+
+    if (init?.signal?.aborted) {
+      return response;
+    }
+
+    await wait(delayMs);
+    attempt += 1;
+  }
+}
+
+function canRetryRequest(init: RequestInit | undefined): boolean {
+  if (!init?.body) {
+    return true;
+  }
+
+  const body = init.body;
+  if (typeof body === "string") {
+    return true;
+  }
+  if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) {
+    return true;
+  }
+  if (typeof ArrayBuffer !== "undefined" && body instanceof ArrayBuffer) {
+    return true;
+  }
+  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(body)) {
+    return true;
+  }
+  if (typeof Blob !== "undefined" && body instanceof Blob) {
+    return true;
+  }
+
+  return false;
+}
+
+async function getRetryDelayMs(
+  response: Response,
+  attempt: number,
+  baseDelayMs: number,
+  maxDelayMs: number,
+): Promise<number | null> {
+  const headerDelayMs = parseRetryAfterMs(response.headers.get("retry-after-ms"));
+  if (headerDelayMs !== null) {
+    return clampDelay(headerDelayMs, maxDelayMs);
+  }
+
+  const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+  if (retryAfter !== null) {
+    return clampDelay(retryAfter, maxDelayMs);
+  }
+
+  const bodyDelayMs = await parseRetryDelayFromBody(response);
+  if (bodyDelayMs !== null) {
+    return clampDelay(bodyDelayMs, maxDelayMs);
+  }
+
+  const fallback = baseDelayMs * Math.pow(2, attempt);
+  return clampDelay(fallback, maxDelayMs);
+}
+
+function clampDelay(delayMs: number, maxDelayMs: number): number {
+  if (!Number.isFinite(delayMs)) {
+    return maxDelayMs;
+  }
+  return Math.min(Math.max(0, delayMs), maxDelayMs);
+}
+
+function parseRetryAfterMs(value: string | null): number | null {
+  if (!value) {
+    return null;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
+  }
+  return parsed;
+}
+
+function parseRetryAfter(value: string | null): number | null {
+  if (!value) {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const asNumber = Number(trimmed);
+  if (Number.isFinite(asNumber)) {
+    return Math.max(0, Math.round(asNumber * 1000));
+  }
+  const asDate = Date.parse(trimmed);
+  if (!Number.isNaN(asDate)) {
+    return Math.max(0, asDate - Date.now());
+  }
+  return null;
+}
+
+async function parseRetryDelayFromBody(response: Response): Promise<number | null> {
+  let text = "";
+  try {
+    text = await response.clone().text();
+  } catch {
+    return null;
+  }
+
+  if (!text) {
+    return null;
+  }
+
+  let parsed: any;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+
+  const details = parsed?.error?.details;
+  if (!Array.isArray(details)) {
+    return null;
+  }
+
+  for (const detail of details) {
+    if (!detail || typeof detail !== "object") {
+      continue;
+    }
+    const retryDelay = (detail as Record<string, unknown>).retryDelay;
+    if (!retryDelay) {
+      continue;
+    }
+    const delayMs = parseRetryDelayValue(retryDelay);
+    if (delayMs !== null) {
+      return delayMs;
+    }
+  }
+
+  return null;
+}
+
+function parseRetryDelayValue(value: unknown): number | null {
+  if (!value) {
+    return null;
+  }
+
+  if (typeof value === "string") {
+    const match = value.match(/^([\d.]+)s$/);
+    if (!match || !match[1]) {
+      return null;
+    }
+    const seconds = Number(match[1]);
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+      return null;
+    }
+    return Math.round(seconds * 1000);
+  }
+
+  if (typeof value === "object") {
+    const record = value as Record<string, unknown>;
+    const seconds = typeof record.seconds === "number" ? record.seconds : 0;
+    const nanos = typeof record.nanos === "number" ? record.nanos : 0;
+    if (!Number.isFinite(seconds) || !Number.isFinite(nanos)) {
+      return null;
+    }
+    const totalMs = Math.round(seconds * 1000 + nanos / 1e6);
+    return totalMs > 0 ? totalMs : null;
+  }
+
+  return null;
+}
+
+function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}