opencode-gemini-auth 1.4.5 → 1.4.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-gemini-auth",
   "module": "index.ts",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "author": "jenslys",
   "repository": "https://github.com/jenslys/opencode-gemini-auth",
   "files": [
@@ -22,7 +22,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "^1.2.10",
+    "@opencode-ai/plugin": "^1.2.20",
     "@openauthjs/openauth": "^0.4.3"
   }
 }

package/src/plugin/oauth-authorize.ts

@@ -4,13 +4,16 @@ import { authorizeGemini, exchangeGeminiWithVerifier } from "../gemini/oauth";
 import type { GeminiTokenExchangeResult } from "../gemini/oauth";
 import { isGeminiDebugEnabled, logGeminiDebugMessage } from "./debug";
 import { resolveProjectContextFromAccessToken } from "./project";
+import { resolveConfiguredProjectId } from "./provider";
 import { startOAuthListener, type OAuthListener } from "./server";
 import type { OAuthAuthDetails } from "./types";
 
 /**
  * Builds the OAuth authorize callback used by plugin auth methods.
  */
-export function createOAuthAuthorizeMethod(): () => Promise<{
+export function createOAuthAuthorizeMethod(options?: {
+  getConfiguredProjectId?: () => string | undefined;
+}): () => Promise<{
   url: string;
   instructions: string;
   method: string;
@@ -24,12 +27,9 @@ export function createOAuthAuthorizeMethod(): () => Promise<{
         return result;
       }
 
-      const projectFromEnv = process.env.OPENCODE_GEMINI_PROJECT_ID?.trim() ?? "";
-      const googleProjectFromEnv =
-        process.env.GOOGLE_CLOUD_PROJECT?.trim() ??
-        process.env.GOOGLE_CLOUD_PROJECT_ID?.trim() ??
-        "";
-      const configuredProjectId = projectFromEnv || googleProjectFromEnv || undefined;
+      const configuredProjectId = resolveConfiguredProjectId({
+        configProjectId: options?.getConfiguredProjectId?.(),
+      });
 
       try {
         const authSnapshot = {

package/src/plugin/project.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it, mock } from "bun:test";
 
+import { formatRefreshParts } from "./auth";
 import { resolveProjectContextFromAccessToken } from "./project";
 import type { OAuthAuthDetails } from "./types";
 
@@ -109,4 +110,28 @@ describe("resolveProjectContextFromAccessToken", () => {
       resolveProjectContextFromAccessToken(baseAuth, baseAuth.access ?? ""),
     ).rejects.toThrow("Google Gemini requires a Google Cloud project");
   });
+
+  it("prefers a configured project id over a persisted managed project id", async () => {
+    const authWithManagedProject: OAuthAuthDetails = {
+      ...baseAuth,
+      refresh: formatRefreshParts({
+        refreshToken: "refresh-token",
+        managedProjectId: "managed-project",
+      }),
+    };
+
+    const fetchMock = mock(async () => {
+      throw new Error("should not fetch project context when a configured project id exists");
+    });
+    (globalThis as { fetch: typeof fetch }).fetch = fetchMock as unknown as typeof fetch;
+
+    const result = await resolveProjectContextFromAccessToken(
+      authWithManagedProject,
+      authWithManagedProject.access ?? "",
+      "configured-project",
+    );
+
+    expect(result.effectiveProjectId).toBe("configured-project");
+    expect(fetchMock.mock.calls.length).toBe(0);
+  });
 });

package/src/plugin/provider.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "bun:test";
+import type { Config } from "@opencode-ai/sdk";
+
+import { resolveConfiguredProjectId, resolveConfiguredProjectIdFromConfig } from "./provider";
+import type { Provider } from "./types";
+
+describe("resolveConfiguredProjectId", () => {
+  it("reads project id from provider options", () => {
+    const provider = {
+      id: "google",
+      name: "Google",
+      source: "config",
+      env: [],
+      options: {
+        projectId: "  provider-project  ",
+      },
+      models: {},
+    } satisfies Provider;
+
+    expect(
+      resolveConfiguredProjectId({
+        provider,
+        env: {},
+      }),
+    ).toBe("provider-project");
+  });
+
+  it("falls back to the top-level config project id when provider options are unavailable", () => {
+    const config = {
+      provider: {
+        google: {
+          options: {
+            projectId: "config-project",
+          },
+        },
+      },
+    } satisfies Config;
+
+    expect(resolveConfiguredProjectIdFromConfig(config)).toBe("config-project");
+    expect(
+      resolveConfiguredProjectId({
+        config,
+        env: {},
+      }),
+    ).toBe("config-project");
+  });
+
+  it("prefers OPENCODE_GEMINI_PROJECT_ID over config and google cloud env vars", () => {
+    expect(
+      resolveConfiguredProjectId({
+        configProjectId: "config-project",
+        env: {
+          OPENCODE_GEMINI_PROJECT_ID: "opencode-project",
+          GOOGLE_CLOUD_PROJECT: "google-project",
+        },
+      }),
+    ).toBe("opencode-project");
+  });
+});

package/src/plugin/provider.ts

@@ -0,0 +1,55 @@
+import type { Config } from "@opencode-ai/sdk";
+
+import { GEMINI_PROVIDER_ID } from "../constants";
+import type { Provider } from "./types";
+
+interface ResolveConfiguredProjectIdInput {
+  provider?: Provider | null;
+  config?: Config | null;
+  configProjectId?: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export function resolveConfiguredProjectId(
+  input: ResolveConfiguredProjectIdInput = {},
+): string | undefined {
+  const env = input.env ?? process.env;
+
+  return (
+    normalizeProjectId(env.OPENCODE_GEMINI_PROJECT_ID) ??
+    resolveConfiguredProjectIdFromProvider(input.provider) ??
+    normalizeProjectId(input.configProjectId) ??
+    resolveConfiguredProjectIdFromConfig(input.config) ??
+    normalizeProjectId(env.GOOGLE_CLOUD_PROJECT) ??
+    normalizeProjectId(env.GOOGLE_CLOUD_PROJECT_ID)
+  );
+}
+
+export function resolveConfiguredProjectIdFromProvider(
+  provider: Provider | null | undefined,
+): string | undefined {
+  if (!provider || typeof provider !== "object") {
+    return undefined;
+  }
+  return normalizeProjectId(provider.options?.projectId);
+}
+
+export function resolveConfiguredProjectIdFromConfig(
+  config: Config | null | undefined,
+): string | undefined {
+  if (!config?.provider || typeof config.provider !== "object") {
+    return undefined;
+  }
+
+  const providerConfig = config.provider[GEMINI_PROVIDER_ID];
+  return normalizeProjectId(providerConfig?.options?.projectId);
+}
+
+function normalizeProjectId(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}

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

@@ -12,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.
  */
@@ -20,6 +25,7 @@ export function prepareGeminiRequest(
   init: RequestInit | undefined,
   accessToken: string,
   projectId: string,
+  thinkingConfigDefaults?: ThinkingConfigDefaults,
 ): {
   request: RequestInfo;
   init: RequestInit;
@@ -61,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;
@@ -97,6 +109,8 @@ function transformRequestBody(
   body: string,
   projectId: string,
   effectiveModel: string,
+  requestedModel: string,
+  thinkingConfigDefaults?: ThinkingConfigDefaults,
 ): { body?: string; userPromptId: string } {
   const fallbackId = randomUUID();
   try {
@@ -115,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);
@@ -139,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;
@@ -152,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

@@ -122,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.ts

@@ -9,9 +9,11 @@ import {
 } from "./plugin/quota";
 import { isGeminiDebugEnabled, logGeminiDebugMessage, startGeminiDebugRequest } from "./plugin/debug";
 import { maybeShowGeminiCapacityToast, maybeShowGeminiTestToast } from "./plugin/notify";
+import { resolveConfiguredProjectId, resolveConfiguredProjectIdFromConfig } from "./plugin/provider";
 import {
   isGenerativeLanguageRequest,
   prepareGeminiRequest,
+  type ThinkingConfigDefaults,
   transformGeminiResponse,
 } from "./plugin/request";
 import { fetchWithRetry } from "./plugin/retry";
@@ -43,6 +45,7 @@ export const GeminiCLIOAuthPlugin = async (
   { client }: PluginContext,
 ): Promise<PluginResult> => ({
   config: async (config) => {
+    latestGeminiConfiguredProjectId = resolveConfiguredProjectIdFromConfig(config);
     config.command = config.command || {};
     config.command[GEMINI_QUOTA_COMMAND] = {
       description: "Show Gemini Code Assist quota usage",
@@ -65,9 +68,13 @@ export const GeminiCLIOAuthPlugin = async (
         return null;
       }
 
-      const configuredProjectId = resolveConfiguredProjectId(provider);
+      const configuredProjectId = resolveConfiguredProjectId({
+        provider,
+        configProjectId: latestGeminiConfiguredProjectId,
+      });
       latestGeminiConfiguredProjectId = configuredProjectId;
       normalizeProviderModelCosts(provider);
+      const thinkingConfigDefaults = resolveThinkingConfigDefaults(provider);
 
       return {
         apiKey: "",
@@ -109,6 +116,7 @@ export const GeminiCLIOAuthPlugin = async (
             init,
             authRecord.access,
             projectContext.effectiveProjectId,
+            thinkingConfigDefaults,
           );
           const debugContext = startGeminiDebugRequest({
             originalUrl: toUrlString(input),
@@ -144,7 +152,9 @@ export const GeminiCLIOAuthPlugin = async (
       {
         label: "OAuth with Google (Gemini CLI)",
         type: "oauth",
-        authorize: createOAuthAuthorizeMethod(),
+        authorize: createOAuthAuthorizeMethod({
+          getConfiguredProjectId: () => latestGeminiConfiguredProjectId,
+        }),
       },
       {
         provider: GEMINI_PROVIDER_ID,
@@ -158,24 +168,6 @@ export const GeminiCLIOAuthPlugin = async (
 export const GoogleOAuthPlugin = GeminiCLIOAuthPlugin;
 const loggedQuotaModelsByProject = new Set<string>();
 
-function resolveConfiguredProjectId(provider: Provider): string | undefined {
-  const providerOptions =
-    provider && typeof provider === "object"
-      ? ((provider as { options?: Record<string, unknown> }).options ?? undefined)
-      : undefined;
-  const projectIdFromConfig =
-    providerOptions && typeof providerOptions.projectId === "string"
-      ? providerOptions.projectId.trim()
-      : "";
-  const projectIdFromEnv = process.env.OPENCODE_GEMINI_PROJECT_ID?.trim() ?? "";
-  const googleProjectIdFromEnv =
-    process.env.GOOGLE_CLOUD_PROJECT?.trim() ??
-    process.env.GOOGLE_CLOUD_PROJECT_ID?.trim() ??
-    "";
-
-  return projectIdFromEnv || projectIdFromConfig || googleProjectIdFromEnv || undefined;
-}
-
 function normalizeProviderModelCosts(provider: Provider): void {
   if (!provider.models) {
     return;
@@ -187,6 +179,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,