opencode-gemini-auth 1.3.10 → 1.3.11

package/src/plugin/{request-helpers.ts → request-helpers/errors.ts}

@@ -1,164 +1,13 @@
-const GEMINI_PREVIEW_LINK = "https://goo.gle/enable-preview-features";
-
-export interface GeminiApiError {
-  code?: number;
-  message?: string;
-  status?: string;
-  details?: unknown[];
-  [key: string]: unknown;
-}
-
-/**
- * Minimal representation of Gemini API responses we touch.
- */
-export interface GeminiApiBody {
-  response?: unknown;
-  error?: GeminiApiError;
-  [key: string]: unknown;
-}
-
-interface GoogleRpcErrorInfo {
-  "@type"?: string;
-  reason?: string;
-  domain?: string;
-  metadata?: Record<string, string>;
-}
-
-interface GoogleRpcHelp {
-  "@type"?: string;
-  links?: Array<{
-    description?: string;
-    url?: string;
-  }>;
-}
-
-interface GoogleRpcQuotaFailure {
-  "@type"?: string;
-  violations?: Array<{
-    subject?: string;
-    description?: string;
-  }>;
-}
-
-interface GoogleRpcRetryInfo {
-  "@type"?: string;
-  retryDelay?: string | { seconds?: number; nanos?: number };
-}
-
-const CLOUDCODE_DOMAINS = [
-  "cloudcode-pa.googleapis.com",
-  "staging-cloudcode-pa.googleapis.com",
-  "autopush-cloudcode-pa.googleapis.com",
-];
-
-export interface GeminiErrorEnhancement {
-  body?: GeminiApiBody;
-  retryAfterMs?: number;
-}
-
-/**
- * Usage metadata exposed by Gemini responses. Fields are optional to reflect partial payloads.
- */
-export interface GeminiUsageMetadata {
-  totalTokenCount?: number;
-  promptTokenCount?: number;
-  candidatesTokenCount?: number;
-  cachedContentTokenCount?: number;
-}
-
-/**
- * Thinking configuration accepted by Gemini.
- * - Gemini 3 models use thinkingLevel (string: 'low', 'medium', 'high')
- * - Gemini 2.5 models use thinkingBudget (number)
- */
-export interface ThinkingConfig {
-  thinkingBudget?: number;
-  thinkingLevel?: string;
-  includeThoughts?: boolean;
-}
-
-/**
- * Normalizes thinkingConfig - passes through values as-is without mapping.
- * User should use thinkingLevel for Gemini 3 and thinkingBudget for Gemini 2.5.
- */
-export function normalizeThinkingConfig(config: unknown): ThinkingConfig | undefined {
-  if (!config || typeof config !== "object") {
-    return undefined;
-  }
-
-  const record = config as Record<string, unknown>;
-  const budgetRaw = record.thinkingBudget ?? record.thinking_budget;
-  const levelRaw = record.thinkingLevel ?? record.thinking_level;
-  const includeRaw = record.includeThoughts ?? record.include_thoughts;
-
-  const thinkingBudget = typeof budgetRaw === "number" && Number.isFinite(budgetRaw) ? budgetRaw : undefined;
-  const thinkingLevel = typeof levelRaw === "string" && levelRaw.length > 0 ? levelRaw.toLowerCase() : undefined;
-  const includeThoughts = typeof includeRaw === "boolean" ? includeRaw : undefined;
-
-  if (thinkingBudget === undefined && thinkingLevel === undefined && includeThoughts === undefined) {
-    return undefined;
-  }
-
-  const normalized: ThinkingConfig = {};
-  if (thinkingBudget !== undefined) {
-    normalized.thinkingBudget = thinkingBudget;
-  }
-  if (thinkingLevel !== undefined) {
-    normalized.thinkingLevel = thinkingLevel;
-  }
-  if (includeThoughts !== undefined) {
-    normalized.includeThoughts = includeThoughts;
-  }
-  return normalized;
-}
-
-/**
- * Parses a Gemini API body; handles array-wrapped responses the API sometimes returns.
- */
-export function parseGeminiApiBody(rawText: string): GeminiApiBody | null {
-  try {
-    const parsed = JSON.parse(rawText);
-    if (Array.isArray(parsed)) {
-      const firstObject = parsed.find((item: unknown) => typeof item === "object" && item !== null);
-      if (firstObject && typeof firstObject === "object") {
-        return firstObject as GeminiApiBody;
-      }
-      return null;
-    }
-
-    if (parsed && typeof parsed === "object") {
-      return parsed as GeminiApiBody;
-    }
-
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Extracts usageMetadata from a response object, guarding types.
- */
-export function extractUsageMetadata(body: GeminiApiBody): GeminiUsageMetadata | null {
-  const usage = (body.response && typeof body.response === "object"
-    ? (body.response as { usageMetadata?: unknown }).usageMetadata
-    : undefined) as GeminiUsageMetadata | undefined;
-
-  if (!usage || typeof usage !== "object") {
-    return null;
-  }
-
-  const asRecord = usage as Record<string, unknown>;
-  const toNumber = (value: unknown): number | undefined =>
-    typeof value === "number" && Number.isFinite(value) ? value : undefined;
-
-  return {
-    totalTokenCount: toNumber(asRecord.totalTokenCount),
-    promptTokenCount: toNumber(asRecord.promptTokenCount),
-    candidatesTokenCount: toNumber(asRecord.candidatesTokenCount),
-    cachedContentTokenCount: toNumber(asRecord.cachedContentTokenCount),
-  };
-}
+import {
+  CLOUDCODE_DOMAINS,
+  GEMINI_PREVIEW_LINK,
+  type GeminiApiBody,
+  type GeminiErrorEnhancement,
+  type GoogleRpcErrorInfo,
+  type GoogleRpcHelp,
+  type GoogleRpcQuotaFailure,
+  type GoogleRpcRetryInfo,
+} from "./types";
 
 /**
  * Enhances 404 errors for Gemini 3 models with a direct preview-access message.
@@ -172,7 +21,7 @@ export function rewriteGeminiPreviewAccessError(
     return null;
   }
 
-  const error: GeminiApiError = body.error ?? {};
+  const error = body.error ?? {};
   const trimmedMessage = typeof error.message === "string" ? error.message.trim() : "";
   const messagePrefix = trimmedMessage.length > 0
     ? trimmedMessage
@@ -188,12 +37,8 @@ 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,
@@ -249,11 +94,7 @@ export function enhanceGeminiErrorResponse(
     }
   }
 
-  if (retryAfterMs !== undefined) {
-    return { retryAfterMs };
-  }
-
-  return null;
+  return retryAfterMs !== undefined ? { retryAfterMs } : null;
 }
 
 function needsPreviewAccessOverride(
@@ -264,26 +105,16 @@ function needsPreviewAccessOverride(
   if (status !== 404) {
     return false;
   }
-
   if (isGeminiThreeModel(requestedModel)) {
     return true;
   }
-
-  const errorMessage = typeof body.error?.message === "string" ? body.error.message : "";
-  return isGeminiThreeModel(errorMessage);
+  return isGeminiThreeModel(typeof body.error?.message === "string" ? body.error.message : "");
 }
 
 function isGeminiThreeModel(target?: string): boolean {
-  if (!target) {
-    return false;
-  }
-
-  return /gemini[\s-]?3/i.test(target);
+  return !!target && /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 =>
@@ -335,9 +166,6 @@ 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 =>
@@ -360,22 +188,19 @@ function extractQuotaInfo(details: unknown[]): { retryable: boolean } | null {
       (detail as GoogleRpcQuotaFailure)["@type"] === "type.googleapis.com/google.rpc.QuotaFailure",
   );
 
-  if (quotaFailure?.violations?.length) {
-    const description = quotaFailure.violations
-      .map((violation) => violation.description?.toLowerCase() ?? "")
-      .join(" ");
-    if (description.includes("daily") || description.includes("per day")) {
-      return { retryable: false };
-    }
-    return { retryable: true };
+  if (!quotaFailure?.violations?.length) {
+    return null;
   }
 
-  return null;
+  const description = quotaFailure.violations
+    .map((violation) => violation.description?.toLowerCase() ?? "")
+    .join(" ");
+  if (description.includes("daily") || description.includes("per day")) {
+    return { retryable: false };
+  }
+  return { retryable: true };
 }
 
-/**
- * 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 =>
@@ -391,27 +216,23 @@ function extractRetryDelay(details: unknown[], errorMessage?: string): number |
     }
   }
 
-  if (errorMessage) {
-    const retryMatch = errorMessage.match(/Please retry in ([0-9.]+(?:ms|s))/);
-    if (retryMatch?.[1]) {
-      return parseRetryDelayValue(retryMatch[1]);
-    }
-    const resetMatch = errorMessage.match(/after\s+([0-9.]+(?:ms|s))/i);
-    if (resetMatch?.[1]) {
-      return parseRetryDelayValue(resetMatch[1]);
-    }
+  if (!errorMessage) {
+    return null;
+  }
+
+  const retryMatch = errorMessage.match(/Please retry in ([0-9.]+(?:ms|s))/);
+  if (retryMatch?.[1]) {
+    return parseRetryDelayValue(retryMatch[1]);
+  }
+  const resetMatch = errorMessage.match(/after\s+([0-9.]+(?:ms|s))/i);
+  if (resetMatch?.[1]) {
+    return parseRetryDelayValue(resetMatch[1]);
   }
 
   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;
-  }
   if (typeof value === "string") {
     const trimmed = value.trim();
     if (!trimmed) {

package/src/plugin/request-helpers/index.ts

@@ -0,0 +1,12 @@
+export {
+  CLOUDCODE_DOMAINS,
+  GEMINI_PREVIEW_LINK,
+  type GeminiApiBody,
+  type GeminiApiError,
+  type GeminiErrorEnhancement,
+  type GeminiUsageMetadata,
+  type ThinkingConfig,
+} from "./types";
+export { normalizeThinkingConfig } from "./thinking";
+export { parseGeminiApiBody, extractUsageMetadata } from "./parsing";
+export { rewriteGeminiPreviewAccessError, enhanceGeminiErrorResponse } from "./errors";

package/src/plugin/request-helpers/parsing.ts

@@ -0,0 +1,44 @@
+import type { GeminiApiBody, GeminiUsageMetadata } from "./types";
+
+/**
+ * Parses a Gemini API body; handles array-wrapped responses the API sometimes returns.
+ */
+export function parseGeminiApiBody(rawText: string): GeminiApiBody | null {
+  try {
+    const parsed = JSON.parse(rawText);
+    if (Array.isArray(parsed)) {
+      const firstObject = parsed.find((item: unknown) => typeof item === "object" && item !== null);
+      return firstObject && typeof firstObject === "object"
+        ? (firstObject as GeminiApiBody)
+        : null;
+    }
+
+    return parsed && typeof parsed === "object" ? (parsed as GeminiApiBody) : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extracts usageMetadata from a response object, guarding types.
+ */
+export function extractUsageMetadata(body: GeminiApiBody): GeminiUsageMetadata | null {
+  const usage = (body.response && typeof body.response === "object"
+    ? (body.response as { usageMetadata?: unknown }).usageMetadata
+    : undefined) as GeminiUsageMetadata | undefined;
+
+  if (!usage || typeof usage !== "object") {
+    return null;
+  }
+
+  const asRecord = usage as Record<string, unknown>;
+  const toNumber = (value: unknown): number | undefined =>
+    typeof value === "number" && Number.isFinite(value) ? value : undefined;
+
+  return {
+    totalTokenCount: toNumber(asRecord.totalTokenCount),
+    promptTokenCount: toNumber(asRecord.promptTokenCount),
+    candidatesTokenCount: toNumber(asRecord.candidatesTokenCount),
+    cachedContentTokenCount: toNumber(asRecord.cachedContentTokenCount),
+  };
+}

package/src/plugin/request-helpers/thinking.ts

@@ -0,0 +1,36 @@
+import type { ThinkingConfig } from "./types";
+
+/**
+ * Normalizes thinkingConfig aliases into canonical Gemini field names.
+ */
+export function normalizeThinkingConfig(config: unknown): ThinkingConfig | undefined {
+  if (!config || typeof config !== "object") {
+    return undefined;
+  }
+
+  const record = config as Record<string, unknown>;
+  const budgetRaw = record.thinkingBudget ?? record.thinking_budget;
+  const levelRaw = record.thinkingLevel ?? record.thinking_level;
+  const includeRaw = record.includeThoughts ?? record.include_thoughts;
+
+  const thinkingBudget = typeof budgetRaw === "number" && Number.isFinite(budgetRaw) ? budgetRaw : undefined;
+  const thinkingLevel = typeof levelRaw === "string" && levelRaw.length > 0 ? levelRaw.toLowerCase() : undefined;
+  const includeThoughts = typeof includeRaw === "boolean" ? includeRaw : undefined;
+
+  if (thinkingBudget === undefined && thinkingLevel === undefined && includeThoughts === undefined) {
+    return undefined;
+  }
+
+  const normalized: ThinkingConfig = {};
+  if (thinkingBudget !== undefined) {
+    normalized.thinkingBudget = thinkingBudget;
+  }
+  if (thinkingLevel !== undefined) {
+    normalized.thinkingLevel = thinkingLevel;
+  }
+  if (includeThoughts !== undefined) {
+    normalized.includeThoughts = includeThoughts;
+  }
+
+  return normalized;
+}

package/src/plugin/request-helpers/types.ts

@@ -0,0 +1,78 @@
+export const GEMINI_PREVIEW_LINK = "https://goo.gle/enable-preview-features";
+
+export interface GeminiApiError {
+  code?: number;
+  message?: string;
+  status?: string;
+  details?: unknown[];
+  [key: string]: unknown;
+}
+
+/**
+ * Minimal representation of Gemini API responses we touch.
+ */
+export interface GeminiApiBody {
+  response?: unknown;
+  error?: GeminiApiError;
+  [key: string]: unknown;
+}
+
+export interface GeminiErrorEnhancement {
+  body?: GeminiApiBody;
+  retryAfterMs?: number;
+}
+
+/**
+ * Usage metadata exposed by Gemini responses. Fields are optional to reflect partial payloads.
+ */
+export interface GeminiUsageMetadata {
+  totalTokenCount?: number;
+  promptTokenCount?: number;
+  candidatesTokenCount?: number;
+  cachedContentTokenCount?: number;
+}
+
+/**
+ * Thinking configuration accepted by Gemini.
+ * - Gemini 3 models use thinkingLevel (string: 'low', 'medium', 'high')
+ * - Gemini 2.5 models use thinkingBudget (number)
+ */
+export interface ThinkingConfig {
+  thinkingBudget?: number;
+  thinkingLevel?: string;
+  includeThoughts?: boolean;
+}
+
+export interface GoogleRpcErrorInfo {
+  "@type"?: string;
+  reason?: string;
+  domain?: string;
+  metadata?: Record<string, string>;
+}
+
+export interface GoogleRpcHelp {
+  "@type"?: string;
+  links?: Array<{
+    description?: string;
+    url?: string;
+  }>;
+}
+
+export interface GoogleRpcQuotaFailure {
+  "@type"?: string;
+  violations?: Array<{
+    subject?: string;
+    description?: string;
+  }>;
+}
+
+export interface GoogleRpcRetryInfo {
+  "@type"?: string;
+  retryDelay?: string | { seconds?: number; nanos?: number };
+}
+
+export const CLOUDCODE_DOMAINS = [
+  "cloudcode-pa.googleapis.com",
+  "staging-cloudcode-pa.googleapis.com",
+  "autopush-cloudcode-pa.googleapis.com",
+];

package/src/plugin/request-helpers.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from "bun:test";
+
+import { enhanceGeminiErrorResponse } from "./request-helpers";
+
+describe("enhanceGeminiErrorResponse", () => {
+  it("adds retry hint and rate-limit message for 429 rate limits", () => {
+    const body = {
+      error: {
+        message: "rate limited",
+        details: [
+          {
+            "@type": "type.googleapis.com/google.rpc.ErrorInfo",
+            reason: "RATE_LIMIT_EXCEEDED",
+            domain: "cloudcode-pa.googleapis.com",
+          },
+          {
+            "@type": "type.googleapis.com/google.rpc.RetryInfo",
+            retryDelay: "5s",
+          },
+        ],
+      },
+    };
+
+    const result = enhanceGeminiErrorResponse(body, 429);
+    expect(result?.retryAfterMs).toBe(5000);
+    expect(result?.body?.error?.message).toContain("Rate limit exceeded");
+  });
+
+  it("adds quota exhausted message for terminal limits", () => {
+    const body = {
+      error: {
+        message: "quota exhausted",
+        details: [
+          {
+            "@type": "type.googleapis.com/google.rpc.ErrorInfo",
+            reason: "QUOTA_EXHAUSTED",
+            domain: "cloudcode-pa.googleapis.com",
+          },
+        ],
+      },
+    };
+
+    const result = enhanceGeminiErrorResponse(body, 429);
+    expect(result?.body?.error?.message).toContain("Quota exhausted");
+    expect(result?.retryAfterMs).toBeUndefined();
+  });
+
+  it("adds validation links for VALIDATION_REQUIRED errors", () => {
+    const body = {
+      error: {
+        message: "validation required",
+        details: [
+          {
+            "@type": "type.googleapis.com/google.rpc.ErrorInfo",
+            reason: "VALIDATION_REQUIRED",
+            domain: "cloudcode-pa.googleapis.com",
+          },
+          {
+            "@type": "type.googleapis.com/google.rpc.Help",
+            links: [
+              { url: "https://example.com/validate" },
+              { description: "Learn more", url: "https://support.google.com/help" },
+            ],
+          },
+        ],
+      },
+    };
+
+    const result = enhanceGeminiErrorResponse(body, 403);
+    expect(result?.body?.error?.message).toContain("Complete validation: https://example.com/validate");
+    expect(result?.body?.error?.message).toContain("Learn more: https://support.google.com/help");
+  });
+
+  it("extracts retry delay from message text when details are missing", () => {
+    const body = {
+      error: {
+        message: "Please retry in 2s",
+      },
+    };
+
+    const result = enhanceGeminiErrorResponse(body, 503);
+    expect(result?.retryAfterMs).toBe(2000);
+  });
+});

package/src/plugin/request.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "bun:test";
+
+import { GEMINI_CODE_ASSIST_ENDPOINT } from "../constants";
+import {
+  isGenerativeLanguageRequest,
+  prepareGeminiRequest,
+  transformGeminiResponse,
+} from "./request";
+
+describe("request helpers", () => {
+  it("detects generativelanguage URLs", () => {
+    expect(
+      isGenerativeLanguageRequest(
+        "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:generateContent",
+      ),
+    ).toBe(true);
+    expect(isGenerativeLanguageRequest("https://example.com/foo")).toBe(false);
+  });
+
+  it("wraps requests for Gemini Code Assist streaming", () => {
+    const input =
+      "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:streamGenerateContent";
+    const init: RequestInit = {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": "should-be-removed",
+      },
+      body: JSON.stringify({
+        contents: [{ role: "user", parts: [{ text: "hi" }] }],
+        system_instruction: { parts: [{ text: "system" }] },
+      }),
+    };
+
+    const result = prepareGeminiRequest(input, init, "token-123", "project-456");
+
+    expect(result.streaming).toBe(true);
+    expect(typeof result.request).toBe("string");
+    expect(result.request).toBe(
+      `${GEMINI_CODE_ASSIST_ENDPOINT}/v1internal:streamGenerateContent?alt=sse`,
+    );
+
+    const headers = new Headers(result.init.headers);
+    expect(headers.get("Authorization")).toBe("Bearer token-123");
+    expect(headers.get("x-api-key")).toBeNull();
+    expect(headers.get("Accept")).toBe("text/event-stream");
+    expect(headers.get("x-activity-request-id")).toBeTruthy();
+
+    const parsed = JSON.parse(result.init.body as string) as Record<string, unknown>;
+    expect(parsed.project).toBe("project-456");
+    expect(parsed.model).toBe("gemini-3-flash-preview");
+    expect(parsed.user_prompt_id).toBeTruthy();
+    expect((parsed.request as Record<string, unknown>).session_id).toBeTruthy();
+    expect((parsed.request as Record<string, unknown>).systemInstruction).toBeDefined();
+    expect((parsed.request as Record<string, unknown>).system_instruction).toBeUndefined();
+  });
+
+  it("maps traceId to responseId for JSON responses", async () => {
+    const response = new Response(
+      JSON.stringify({
+        traceId: "trace-123",
+        response: {
+          candidates: [],
+        },
+      }),
+      {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      },
+    );
+
+    const transformed = await transformGeminiResponse(response, false);
+    const parsed = (await transformed.json()) as Record<string, unknown>;
+    expect(parsed.responseId).toBe("trace-123");
+  });
+
+  it("maps traceId to responseId for streaming payloads", async () => {
+    const response = new Response(
+      'data: {"traceId":"trace-456","response":{"candidates":[]}}\n\n',
+      {
+        status: 200,
+        headers: { "content-type": "text/event-stream" },
+      },
+    );
+
+    const transformed = await transformGeminiResponse(response, true);
+    const payload = await transformed.text();
+    expect(payload).toContain('"responseId":"trace-456"');
+    expect(payload).not.toContain('"traceId"');
+  });
+});