opencode-gemini-auth 1.3.9 → 1.3.10

package/README.md

@@ -189,6 +189,17 @@ OPENCODE_GEMINI_DEBUG=1 opencode
 This will generate `gemini-debug-<timestamp>.log` files in your working
 directory containing sanitized request/response details.
 
+## Parity Notes
+
+This plugin mirrors the official Gemini CLI OAuth flow and Code Assist
+endpoints. In particular, project onboarding and quota retry handling follow
+the same behavior patterns as the Gemini CLI.
+
+### References
+
+- Gemini CLI repository: https://github.com/google-gemini/gemini-cli
+- Gemini CLI quota documentation: https://developers.google.com/gemini-code-assist/resources/quotas
+
 ### Updating
 
 Opencode does not automatically update plugins. To update to the latest version,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-gemini-auth",
   "module": "index.ts",
-  "version": "1.3.9",
+  "version": "1.3.10",
   "author": "jenslys",
   "repository": "https://github.com/jenslys/opencode-gemini-auth",
   "files": [

package/src/plugin/project.ts

@@ -134,6 +134,9 @@ function buildIneligibleTierMessage(tiers?: GeminiIneligibleTier[]): string | un
   return reasons.join(", ");
 }
 
+/**
+ * Detects VPC-SC errors from Cloud Code responses.
+ */
 function isVpcScError(payload: unknown): boolean {
   if (!payload || typeof payload !== "object") {
     return false;
@@ -155,6 +158,9 @@ function isVpcScError(payload: unknown): boolean {
   });
 }
 
+/**
+ * Safely parses JSON, returning null on failure.
+ */
 function parseJsonSafe(text: string): unknown {
   try {
     return JSON.parse(text);
@@ -402,9 +408,10 @@ export async function resolveProjectContextFromAccessToken(
   const projectId = effectiveConfiguredProjectId ?? parts.projectId;
 
   if (projectId || parts.managedProjectId) {
+    const effectiveProjectId = projectId || parts.managedProjectId || "";
     return {
       auth,
-      effectiveProjectId: projectId || parts.managedProjectId || "",
+      effectiveProjectId,
     };
   }
 
@@ -467,12 +474,12 @@ export async function resolveProjectContextFromAccessToken(
       await persistAuth(updatedAuth);
     }
 
-    return { auth: updatedAuth, effectiveProjectId: onboardedProjectId };
-  }
+      return { auth: updatedAuth, effectiveProjectId: onboardedProjectId };
+    }
 
-  if (projectId) {
-    return { auth, effectiveProjectId: projectId };
-  }
+    if (projectId) {
+      return { auth, effectiveProjectId: projectId };
+    }
 
   throw new ProjectIdRequiredError();
 }

package/src/plugin/request-helpers.ts

@@ -191,6 +191,10 @@ export function rewriteGeminiPreviewAccessError(
 /**
  * Enhances Gemini error responses with friendly messages and retry hints.
  */
+/**
+ * Enhances Gemini errors with validation/quota messaging and retry hints.
+ * Keeps messaging aligned with Gemini CLI's Cloud Code error handling.
+ */
 export function enhanceGeminiErrorResponse(
   body: GeminiApiBody,
   status: number,
@@ -277,6 +281,9 @@ function isGeminiThreeModel(target?: string): boolean {
   return /gemini[\s-]?3/i.test(target);
 }
 
+/**
+ * Extracts validation URLs when the backend requires account verification.
+ */
 function extractValidationInfo(details: unknown[]): { link?: string; learnMore?: string } | null {
   const errorInfo = details.find(
     (detail): detail is GoogleRpcErrorInfo =>
@@ -328,6 +335,9 @@ function extractValidationInfo(details: unknown[]): { link?: string; learnMore?:
   return link || learnMore ? { link, learnMore } : null;
 }
 
+/**
+ * Classifies quota-related error details as retryable or terminal.
+ */
 function extractQuotaInfo(details: unknown[]): { retryable: boolean } | null {
   const errorInfo = details.find(
     (detail): detail is GoogleRpcErrorInfo =>
@@ -363,6 +373,9 @@ function extractQuotaInfo(details: unknown[]): { retryable: boolean } | null {
   return null;
 }
 
+/**
+ * Extracts retry delay hints from structured error details or message text.
+ */
 function extractRetryDelay(details: unknown[], errorMessage?: string): number | null {
   const retryInfo = details.find(
     (detail): detail is GoogleRpcRetryInfo =>
@@ -392,6 +405,9 @@ function extractRetryDelay(details: unknown[], errorMessage?: string): number |
   return null;
 }
 
+/**
+ * Parses retry delay values from strings or protobuf-style objects.
+ */
 function parseRetryDelayValue(value: string | { seconds?: number; nanos?: number }): number | null {
   if (!value) {
     return null;

package/src/plugin.ts

@@ -323,6 +323,11 @@ 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;
+const CLOUDCODE_DOMAINS = [
+  "cloudcode-pa.googleapis.com",
+  "staging-cloudcode-pa.googleapis.com",
+  "autopush-cloudcode-pa.googleapis.com",
+];
 
 function toUrlString(value: RequestInfo): string {
   if (typeof value === "string") {
@@ -387,6 +392,10 @@ function openBrowserUrl(url: string): void {
   }
 }
 
+/**
+ * Sends requests with bounded retry logic for transient Cloud Code failures.
+ * Mirrors the Gemini CLI handling of Code Assist rate-limit signals.
+ */
 async function fetchWithRetry(input: RequestInfo, init: RequestInit | undefined): Promise<Response> {
   const maxRetries = DEFAULT_MAX_RETRIES;
   const baseDelayMs = DEFAULT_BASE_DELAY_MS;
@@ -403,7 +412,22 @@ async function fetchWithRetry(input: RequestInfo, init: RequestInit | undefined)
       return response;
     }
 
-    const delayMs = await getRetryDelayMs(response, attempt, baseDelayMs, maxDelayMs);
+    let retryDelayMs: number | null = null;
+    if (response.status === 429) {
+      const quotaContext = await classifyQuotaResponse(response);
+      if (quotaContext?.terminal) {
+        return response;
+      }
+      retryDelayMs = quotaContext?.retryDelayMs ?? null;
+    }
+
+    const delayMs = await getRetryDelayMs(
+      response,
+      attempt,
+      baseDelayMs,
+      maxDelayMs,
+      retryDelayMs,
+    );
     if (!delayMs || delayMs <= 0) {
       return response;
     }
@@ -442,11 +466,16 @@ function canRetryRequest(init: RequestInit | undefined): boolean {
   return false;
 }
 
+/**
+ * Resolves a retry delay from headers, body hints, or exponential backoff.
+ * Honors RetryInfo/Retry-After hints emitted by Code Assist.
+ */
 async function getRetryDelayMs(
   response: Response,
   attempt: number,
   baseDelayMs: number,
   maxDelayMs: number,
+  bodyDelayMs: number | null = null,
 ): Promise<number | null> {
   const headerDelayMs = parseRetryAfterMs(response.headers.get("retry-after-ms"));
   if (headerDelayMs !== null) {
@@ -458,9 +487,9 @@ async function getRetryDelayMs(
     return clampDelay(retryAfter, maxDelayMs);
   }
 
-  const bodyDelayMs = await parseRetryDelayFromBody(response);
-  if (bodyDelayMs !== null) {
-    return clampDelay(bodyDelayMs, maxDelayMs);
+  const parsedBodyDelayMs = bodyDelayMs ?? (await parseRetryDelayFromBody(response));
+  if (parsedBodyDelayMs !== null) {
+    return clampDelay(parsedBodyDelayMs, maxDelayMs);
   }
 
   const fallback = baseDelayMs * Math.pow(2, attempt);
@@ -525,7 +554,8 @@ async function parseRetryDelayFromBody(response: Response): Promise<number | nul
 
   const details = parsed?.error?.details;
   if (!Array.isArray(details)) {
-    return null;
+    const message = typeof parsed?.error?.message === "string" ? parsed.error.message : "";
+    return parseRetryDelayFromMessage(message);
   }
 
   for (const detail of details) {
@@ -542,7 +572,8 @@ async function parseRetryDelayFromBody(response: Response): Promise<number | nul
     }
   }
 
-  return null;
+  const message = typeof parsed?.error?.message === "string" ? parsed.error.message : "";
+  return parseRetryDelayFromMessage(message);
 }
 
 function parseRetryDelayValue(value: unknown): number | null {
@@ -576,6 +607,91 @@ function parseRetryDelayValue(value: unknown): number | null {
   return null;
 }
 
+/**
+ * Parses retry delays embedded in error message strings (e.g., "Please retry in 5s").
+ */
+function parseRetryDelayFromMessage(message: string): number | null {
+  if (!message) {
+    return null;
+  }
+  const retryMatch = message.match(/Please retry in ([0-9.]+(?:ms|s))/);
+  if (retryMatch?.[1]) {
+    return parseRetryDelayValue(retryMatch[1]);
+  }
+  const afterMatch = message.match(/after\s+([0-9.]+(?:ms|s))/i);
+  if (afterMatch?.[1]) {
+    return parseRetryDelayValue(afterMatch[1]);
+  }
+  return null;
+}
+
+/**
+ * Classifies quota errors as terminal vs retryable and extracts retry hints.
+ * Matches Gemini CLI semantics: QUOTA_EXHAUSTED is terminal, RATE_LIMIT_EXCEEDED is retryable.
+ */
+async function classifyQuotaResponse(
+  response: Response,
+): Promise<{ terminal: boolean; retryDelayMs?: 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 error = parsed?.error ?? {};
+  const details = Array.isArray(error?.details) ? error.details : [];
+  const retryDelayMs = parseRetryDelayFromMessage(error?.message ?? "") ?? undefined;
+
+  const errorInfo = details.find(
+    (detail: any) =>
+      detail &&
+      typeof detail === "object" &&
+      detail["@type"] === "type.googleapis.com/google.rpc.ErrorInfo",
+  );
+
+  if (errorInfo?.domain && !CLOUDCODE_DOMAINS.includes(errorInfo.domain)) {
+    return null;
+  }
+
+  if (errorInfo?.reason === "QUOTA_EXHAUSTED") {
+    return { terminal: true, retryDelayMs };
+  }
+  if (errorInfo?.reason === "RATE_LIMIT_EXCEEDED") {
+    return { terminal: false, retryDelayMs };
+  }
+
+  const quotaFailure = details.find(
+    (detail: any) =>
+      detail &&
+      typeof detail === "object" &&
+      detail["@type"] === "type.googleapis.com/google.rpc.QuotaFailure",
+  );
+
+  if (quotaFailure?.violations && Array.isArray(quotaFailure.violations)) {
+    const combined = quotaFailure.violations
+      .map((violation: any) => String(violation?.description ?? "").toLowerCase())
+      .join(" ");
+    if (combined.includes("daily") || combined.includes("per day")) {
+      return { terminal: true, retryDelayMs };
+    }
+    return { terminal: false, retryDelayMs };
+  }
+
+  return { terminal: false, retryDelayMs };
+}
+
 function wait(ms: number): Promise<void> {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);