opencode-gemini-auth 1.4.4 → 1.4.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-gemini-auth",
   "module": "index.ts",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "author": "jenslys",
   "repository": "https://github.com/jenslys/opencode-gemini-auth",
   "files": [
@@ -11,7 +11,9 @@
   "license": "MIT",
   "type": "module",
   "scripts": {
-    "update:gemini-cli": "git -C .local/gemini-cli pull --ff-only"
+    "update:gemini-cli": "git -C .local/gemini-cli pull --ff-only",
+    "update:gemini-cli-version": "node commands/sync-gemini-cli-version.mjs",
+    "update:gemini-cli-sync": "npm run update:gemini-cli && npm run update:gemini-cli-version"
   },
   "devDependencies": {
     "@types/bun": "latest"

package/src/constants.ts

@@ -28,7 +28,6 @@ export const GEMINI_REDIRECT_URI = "http://localhost:8085/oauth2callback";
 export const GEMINI_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
 
 export const CODE_ASSIST_HEADERS = {
-  "User-Agent": "google-api-nodejs-client/9.15.1",
   "X-Goog-Api-Client": "gl-node/22.17.0",
   "Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI",
 } as const;

package/src/plugin/gemini-cli-version.ts

@@ -0,0 +1,5 @@
+/**
+ * Synced from `.local/gemini-cli/packages/cli/package.json`.
+ * Update with: `npm run update:gemini-cli-version`
+ */
+export const GEMINI_CLI_VERSION = "0.30.0-nightly.20260210.a2174751d";

package/src/plugin/project/api.ts

@@ -1,5 +1,6 @@
 import { CODE_ASSIST_HEADERS, GEMINI_CODE_ASSIST_ENDPOINT } from "../../constants";
 import { logGeminiDebugResponse, startGeminiDebugRequest } from "../debug";
+import { buildGeminiCliUserAgent } from "../user-agent";
 import {
   FREE_TIER_ID,
   type LoadCodeAssistPayload,
@@ -27,6 +28,7 @@ export async function loadManagedProject(
     const headers = {
       "Content-Type": "application/json",
       Authorization: `Bearer ${accessToken}`,
+      "User-Agent": buildGeminiCliUserAgent(),
       ...CODE_ASSIST_HEADERS,
     };
     const debugContext = startGeminiDebugRequest({
@@ -92,6 +94,7 @@ export async function onboardManagedProject(
   const headers = {
     "Content-Type": "application/json",
     Authorization: `Bearer ${accessToken}`,
+    "User-Agent": buildGeminiCliUserAgent(),
     ...CODE_ASSIST_HEADERS,
   };
 
@@ -143,6 +146,7 @@ export async function retrieveUserQuota(
   const headers = {
     "Content-Type": "application/json",
     Authorization: `Bearer ${accessToken}`,
+    "User-Agent": buildGeminiCliUserAgent(),
     ...CODE_ASSIST_HEADERS,
   };
 

package/src/plugin/request/index.ts

@@ -1,3 +1,4 @@
 export { prepareGeminiRequest } from "./prepare";
+export type { ThinkingConfigDefaults } from "./prepare";
 export { transformGeminiResponse } from "./response";
 export { isGenerativeLanguageRequest } from "./shared";

package/src/plugin/request/prepare.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 
 import { CODE_ASSIST_HEADERS, GEMINI_CODE_ASSIST_ENDPOINT } from "../../constants";
 import { normalizeThinkingConfig } from "../request-helpers";
+import { buildGeminiCliUserAgent } from "../user-agent";
 import { normalizeRequestPayloadIdentifiers, normalizeWrappedIdentifiers } from "./identifiers";
 import { addThoughtSignaturesToFunctionCalls, transformOpenAIToolCalls } from "./openai";
 import { isGenerativeLanguageRequest, toRequestUrlString } from "./shared";
@@ -11,6 +12,11 @@ const MODEL_FALLBACKS: Record<string, string> = {
   "gemini-2.5-flash-image": "gemini-2.5-flash",
 };
 
+export interface ThinkingConfigDefaults {
+  provider?: unknown;
+  models?: Record<string, unknown>;
+}
+
 /**
  * Rewrites OpenAI-style requests into Gemini Code Assist request shape.
  */
@@ -19,6 +25,7 @@ export function prepareGeminiRequest(
   init: RequestInit | undefined,
   accessToken: string,
   projectId: string,
+  thinkingConfigDefaults?: ThinkingConfigDefaults,
 ): {
   request: RequestInfo;
   init: RequestInit;
@@ -38,6 +45,7 @@ export function prepareGeminiRequest(
 
   headers.set("Authorization", `Bearer ${accessToken}`);
   headers.delete("x-api-key");
+  headers.delete("x-goog-api-key");
 
   const match = toRequestUrlString(input).match(/\/models\/([^:]+):(\w+)/);
   if (!match) {
@@ -59,7 +67,13 @@ export function prepareGeminiRequest(
   let requestIdentifier: string = randomUUID();
 
   if (typeof baseInit.body === "string" && baseInit.body) {
-    const transformed = transformRequestBody(baseInit.body, projectId, effectiveModel);
+    const transformed = transformRequestBody(
+      baseInit.body,
+      projectId,
+      effectiveModel,
+      rawModel,
+      thinkingConfigDefaults,
+    );
     if (transformed.body) {
       body = transformed.body;
       requestIdentifier = transformed.userPromptId;
@@ -70,7 +84,7 @@ export function prepareGeminiRequest(
     headers.set("Accept", "text/event-stream");
   }
 
-  headers.set("User-Agent", CODE_ASSIST_HEADERS["User-Agent"]);
+  headers.set("User-Agent", buildGeminiCliUserAgent(effectiveModel));
   headers.set("X-Goog-Api-Client", CODE_ASSIST_HEADERS["X-Goog-Api-Client"]);
   headers.set("Client-Metadata", CODE_ASSIST_HEADERS["Client-Metadata"]);
   /**
@@ -95,6 +109,8 @@ function transformRequestBody(
   body: string,
   projectId: string,
   effectiveModel: string,
+  requestedModel: string,
+  thinkingConfigDefaults?: ThinkingConfigDefaults,
 ): { body?: string; userPromptId: string } {
   const fallbackId = randomUUID();
   try {
@@ -113,7 +129,11 @@ function transformRequestBody(
     const requestPayload = { ...parsedBody };
     transformOpenAIToolCalls(requestPayload);
     addThoughtSignaturesToFunctionCalls(requestPayload);
-    normalizeThinking(requestPayload);
+    normalizeThinking(
+      requestPayload,
+      resolveDefaultThinkingConfig(thinkingConfigDefaults, requestedModel, effectiveModel),
+      thinkingConfigDefaults?.provider,
+    );
     normalizeSystemInstruction(requestPayload);
     normalizeCachedContent(requestPayload);
     stripThoughtPartsFromHistory(requestPayload);
@@ -137,9 +157,30 @@ function transformRequestBody(
   }
 }
 
-function normalizeThinking(requestPayload: Record<string, unknown>): void {
+function resolveDefaultThinkingConfig(
+  thinkingConfigDefaults: ThinkingConfigDefaults | undefined,
+  requestedModel: string,
+  effectiveModel: string,
+): unknown {
+  if (!thinkingConfigDefaults?.models) {
+    return undefined;
+  }
+
+  return thinkingConfigDefaults.models[requestedModel] ?? thinkingConfigDefaults.models[effectiveModel];
+}
+
+function normalizeThinking(
+  requestPayload: Record<string, unknown>,
+  modelThinkingConfig: unknown,
+  providerThinkingConfig: unknown,
+): void {
   const rawGenerationConfig = requestPayload.generationConfig as Record<string, unknown> | undefined;
-  const normalizedThinking = normalizeThinkingConfig(rawGenerationConfig?.thinkingConfig);
+  const hasRequestThinkingConfig =
+    !!rawGenerationConfig && Object.prototype.hasOwnProperty.call(rawGenerationConfig, "thinkingConfig");
+  const sourceThinkingConfig = hasRequestThinkingConfig
+    ? rawGenerationConfig?.thinkingConfig
+    : modelThinkingConfig ?? providerThinkingConfig;
+  const normalizedThinking = normalizeThinkingConfig(sourceThinkingConfig);
   if (normalizedThinking) {
     if (rawGenerationConfig) {
       rawGenerationConfig.thinkingConfig = normalizedThinking;
@@ -150,7 +191,7 @@ function normalizeThinking(requestPayload: Record<string, unknown>): void {
     return;
   }
 
-  if (rawGenerationConfig?.thinkingConfig) {
+  if (hasRequestThinkingConfig && rawGenerationConfig) {
     delete rawGenerationConfig.thinkingConfig;
     requestPayload.generationConfig = rawGenerationConfig;
   }

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

@@ -14,13 +14,19 @@ export function normalizeThinkingConfig(config: unknown): ThinkingConfig | undef
   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 thinkingLevel =
+    typeof levelRaw === "string" && levelRaw.trim().length > 0 ? levelRaw.trim().toLowerCase() : undefined;
   const includeThoughts = typeof includeRaw === "boolean" ? includeRaw : undefined;
 
   if (thinkingBudget === undefined && thinkingLevel === undefined && includeThoughts === undefined) {
     return undefined;
   }
 
+  const thinkingEnabled =
+    (thinkingBudget !== undefined && thinkingBudget > 0) ||
+    thinkingLevel !== undefined;
+  const finalIncludeThoughts = thinkingEnabled ? includeThoughts ?? false : false;
+
   const normalized: ThinkingConfig = {};
   if (thinkingBudget !== undefined) {
     normalized.thinkingBudget = thinkingBudget;
@@ -28,9 +34,7 @@ export function normalizeThinkingConfig(config: unknown): ThinkingConfig | undef
   if (thinkingLevel !== undefined) {
     normalized.thinkingLevel = thinkingLevel;
   }
-  if (includeThoughts !== undefined) {
-    normalized.includeThoughts = includeThoughts;
-  }
+  normalized.includeThoughts = finalIncludeThoughts;
 
   return normalized;
 }

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

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
 
-import { enhanceGeminiErrorResponse } from "./request-helpers";
+import { enhanceGeminiErrorResponse, normalizeThinkingConfig } from "./request-helpers";
 
 describe("enhanceGeminiErrorResponse", () => {
   it("adds retry hint and rate-limit message for 429 rate limits", () => {
@@ -82,3 +82,24 @@ describe("enhanceGeminiErrorResponse", () => {
     expect(result?.retryAfterMs).toBe(2000);
   });
 });
+
+describe("normalizeThinkingConfig", () => {
+  it("forces includeThoughts to false when thinking is not enabled", () => {
+    expect(normalizeThinkingConfig({ includeThoughts: true })).toEqual({ includeThoughts: false });
+    expect(normalizeThinkingConfig({ thinkingBudget: 0, includeThoughts: true })).toEqual({
+      thinkingBudget: 0,
+      includeThoughts: false,
+    });
+  });
+
+  it("keeps includeThoughts when thinking is enabled by budget or level", () => {
+    expect(normalizeThinkingConfig({ thinkingBudget: 8192, includeThoughts: true })).toEqual({
+      thinkingBudget: 8192,
+      includeThoughts: true,
+    });
+    expect(normalizeThinkingConfig({ thinkingLevel: "HIGH", includeThoughts: true })).toEqual({
+      thinkingLevel: "high",
+      includeThoughts: true,
+    });
+  });
+});

package/src/plugin/request.test.ts

@@ -25,6 +25,7 @@ describe("request helpers", () => {
       headers: {
         "Content-Type": "application/json",
         "x-api-key": "should-be-removed",
+        "x-goog-api-key": "should-also-be-removed",
       },
       body: JSON.stringify({
         contents: [{ role: "user", parts: [{ text: "hi" }] }],
@@ -43,6 +44,9 @@ describe("request helpers", () => {
     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("x-goog-api-key")).toBeNull();
+    expect(headers.get("User-Agent")).toContain("GeminiCLI/");
+    expect(headers.get("User-Agent")).toContain("/gemini-3-flash-preview ");
     expect(headers.get("Accept")).toBe("text/event-stream");
     expect(headers.get("x-activity-request-id")).toBeTruthy();
 
@@ -118,4 +122,80 @@ describe("request helpers", () => {
     expect(payload).toContain('"responseId":"trace-456"');
     expect(payload).not.toContain('"traceId"');
   });
+
+  it("injects model-level thinking defaults when request has no thinkingConfig", () => {
+    const input =
+      "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:generateContent";
+    const init: RequestInit = {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        contents: [{ role: "user", parts: [{ text: "hi" }] }],
+      }),
+    };
+
+    const result = prepareGeminiRequest(input, init, "token-123", "project-456", {
+      models: {
+        "gemini-3-flash-preview": {
+          thinkingLevel: "HIGH",
+          includeThoughts: true,
+        },
+      },
+      provider: {
+        thinkingLevel: "low",
+        includeThoughts: false,
+      },
+    });
+
+    const parsed = JSON.parse(result.init.body as string) as Record<string, unknown>;
+    const request = parsed.request as Record<string, unknown>;
+    const generationConfig = request.generationConfig as Record<string, unknown>;
+    expect(generationConfig.thinkingConfig).toEqual({
+      thinkingLevel: "high",
+      includeThoughts: true,
+    });
+  });
+
+  it("prefers request thinkingConfig over model/provider defaults", () => {
+    const input =
+      "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:generateContent";
+    const init: RequestInit = {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        contents: [{ role: "user", parts: [{ text: "hi" }] }],
+        generationConfig: {
+          thinkingConfig: {
+            thinkingLevel: "low",
+            includeThoughts: false,
+          },
+        },
+      }),
+    };
+
+    const result = prepareGeminiRequest(input, init, "token-123", "project-456", {
+      models: {
+        "gemini-3-flash-preview": {
+          thinkingLevel: "high",
+          includeThoughts: true,
+        },
+      },
+      provider: {
+        thinkingLevel: "high",
+        includeThoughts: true,
+      },
+    });
+
+    const parsed = JSON.parse(result.init.body as string) as Record<string, unknown>;
+    const request = parsed.request as Record<string, unknown>;
+    const generationConfig = request.generationConfig as Record<string, unknown>;
+    expect(generationConfig.thinkingConfig).toEqual({
+      thinkingLevel: "low",
+      includeThoughts: false,
+    });
+  });
 });

package/src/plugin/user-agent.test.ts

@@ -0,0 +1,50 @@
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { GEMINI_CLI_VERSION } from "./gemini-cli-version";
+import { buildGeminiCliUserAgent, getGeminiCliVersion, userAgentInternals } from "./user-agent";
+
+const originalNpmPackageVersion = process.env.npm_package_version;
+const originalExplicitVersion = process.env.OPENCODE_GEMINI_CLI_VERSION;
+
+describe("user-agent", () => {
+  afterEach(() => {
+    if (originalNpmPackageVersion === undefined) {
+      delete process.env.npm_package_version;
+    } else {
+      process.env.npm_package_version = originalNpmPackageVersion;
+    }
+    if (originalExplicitVersion === undefined) {
+      delete process.env.OPENCODE_GEMINI_CLI_VERSION;
+    } else {
+      process.env.OPENCODE_GEMINI_CLI_VERSION = originalExplicitVersion;
+    }
+    userAgentInternals.resetCache();
+  });
+
+  it("prefers OPENCODE_GEMINI_CLI_VERSION when available", () => {
+    process.env.OPENCODE_GEMINI_CLI_VERSION = "8.8.8-explicit";
+    process.env.npm_package_version = "9.9.9-test";
+    userAgentInternals.resetCache();
+
+    expect(getGeminiCliVersion()).toBe("8.8.8-explicit");
+    expect(buildGeminiCliUserAgent("gemini-3-flash-preview")).toContain("/8.8.8-explicit/");
+  });
+
+  it("prefers synced GEMINI_CLI_VERSION over npm_package_version", () => {
+    delete process.env.OPENCODE_GEMINI_CLI_VERSION;
+    process.env.npm_package_version = "9.9.9-test";
+    userAgentInternals.resetCache();
+
+    expect(getGeminiCliVersion()).toBe(GEMINI_CLI_VERSION);
+  });
+
+  it("builds a GeminiCLI-style user agent", () => {
+    delete process.env.OPENCODE_GEMINI_CLI_VERSION;
+    delete process.env.npm_package_version;
+    userAgentInternals.resetCache();
+
+    const userAgent = buildGeminiCliUserAgent("gemini-3-flash-preview");
+    expect(userAgent).toContain("GeminiCLI/");
+    expect(userAgent).toContain(`/gemini-3-flash-preview `);
+  });
+});

package/src/plugin/user-agent.ts

@@ -0,0 +1,76 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { GEMINI_CLI_VERSION } from "./gemini-cli-version";
+
+const GEMINI_CLI_UA_NAME = "GeminiCLI";
+const GEMINI_CLI_DEFAULT_MODEL = "gemini-code-assist";
+
+let cachedGeminiCliVersion: string | undefined;
+
+/**
+ * Resolves plugin version for User-Agent:
+ * 1) explicit override (`OPENCODE_GEMINI_CLI_VERSION`)
+ * 2) synced Gemini CLI version file (`src/plugin/gemini-cli-version.ts`)
+ * 3) package-manager runtime env (`npm_package_version`)
+ * 4) local package.json next to the plugin sources
+ * 5) cwd package.json as final fallback
+ */
+export function getGeminiCliVersion(): string {
+  if (cachedGeminiCliVersion) {
+    return cachedGeminiCliVersion;
+  }
+
+  const explicitVersion = process.env.OPENCODE_GEMINI_CLI_VERSION?.trim();
+  if (explicitVersion) {
+    cachedGeminiCliVersion = explicitVersion;
+    return cachedGeminiCliVersion;
+  }
+
+  if (GEMINI_CLI_VERSION.trim()) {
+    cachedGeminiCliVersion = GEMINI_CLI_VERSION.trim();
+    return cachedGeminiCliVersion;
+  }
+
+  const envVersion = process.env.npm_package_version?.trim();
+  if (envVersion) {
+    cachedGeminiCliVersion = envVersion;
+    return cachedGeminiCliVersion;
+  }
+
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const candidatePaths = [
+    join(moduleDir, "../../package.json"),
+    join(moduleDir, "../package.json"),
+    join(process.cwd(), "package.json"),
+  ];
+
+  for (const packagePath of candidatePaths) {
+    try {
+      const parsed = JSON.parse(readFileSync(packagePath, "utf8")) as { version?: unknown };
+      if (typeof parsed.version === "string" && parsed.version.trim()) {
+        cachedGeminiCliVersion = parsed.version.trim();
+        return cachedGeminiCliVersion;
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  cachedGeminiCliVersion = "0.0.0";
+  return cachedGeminiCliVersion;
+}
+
+/**
+ * Builds a Gemini CLI-style User-Agent string.
+ */
+export function buildGeminiCliUserAgent(model?: string): string {
+  const modelSegment = model?.trim() || GEMINI_CLI_DEFAULT_MODEL;
+  return `${GEMINI_CLI_UA_NAME}/${getGeminiCliVersion()}/${modelSegment} (${process.platform}; ${process.arch})`;
+}
+
+export const userAgentInternals = {
+  resetCache() {
+    cachedGeminiCliVersion = undefined;
+  },
+};

package/src/plugin.ts

@@ -12,6 +12,7 @@ import { maybeShowGeminiCapacityToast, maybeShowGeminiTestToast } from "./plugin
 import {
   isGenerativeLanguageRequest,
   prepareGeminiRequest,
+  type ThinkingConfigDefaults,
   transformGeminiResponse,
 } from "./plugin/request";
 import { fetchWithRetry } from "./plugin/retry";
@@ -68,6 +69,7 @@ export const GeminiCLIOAuthPlugin = async (
       const configuredProjectId = resolveConfiguredProjectId(provider);
       latestGeminiConfiguredProjectId = configuredProjectId;
       normalizeProviderModelCosts(provider);
+      const thinkingConfigDefaults = resolveThinkingConfigDefaults(provider);
 
       return {
         apiKey: "",
@@ -109,6 +111,7 @@ export const GeminiCLIOAuthPlugin = async (
             init,
             authRecord.access,
             projectContext.effectiveProjectId,
+            thinkingConfigDefaults,
           );
           const debugContext = startGeminiDebugRequest({
             originalUrl: toUrlString(input),
@@ -187,6 +190,34 @@ function normalizeProviderModelCosts(provider: Provider): void {
   }
 }
 
+function resolveThinkingConfigDefaults(provider: Provider): ThinkingConfigDefaults | undefined {
+  const providerOptions =
+    provider && typeof provider === "object"
+      ? ((provider as { options?: Record<string, unknown> }).options ?? undefined)
+      : undefined;
+  const providerThinkingConfig = providerOptions?.thinkingConfig;
+
+  const modelThinkingConfigByModel: Record<string, unknown> = {};
+  for (const [modelId, model] of Object.entries(provider.models ?? {})) {
+    if (!model || typeof model !== "object") {
+      continue;
+    }
+    const modelOptions = (model as { options?: Record<string, unknown> }).options;
+    if (modelOptions && typeof modelOptions === "object" && "thinkingConfig" in modelOptions) {
+      modelThinkingConfigByModel[modelId] = modelOptions.thinkingConfig;
+    }
+  }
+
+  if (providerThinkingConfig === undefined && Object.keys(modelThinkingConfigByModel).length === 0) {
+    return undefined;
+  }
+
+  return {
+    provider: providerThinkingConfig,
+    models: modelThinkingConfigByModel,
+  };
+}
+
 async function ensureProjectContextOrThrow(
   authRecord: OAuthAuthDetails,
   client: PluginClient,