refactor(request): resolve default thinking config

Author: jenslys

package.json

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

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,

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,
+    });
+  });
+});

src/plugin/request-helpers/thinking.ts

@@ -14,23 +14,27 @@ 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;
   }
   if (thinkingLevel !== undefined) {
     normalized.thinkingLevel = thinkingLevel;
   }
-  if (includeThoughts !== undefined) {
-    normalized.includeThoughts = includeThoughts;
-  }
+  normalized.includeThoughts = finalIncludeThoughts;
 
   return normalized;
 }

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,
+    });
+  });
 });

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";

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;
   }