fix(models): restore Sol-exclusive 'max' reasoning value; fix Gemini 2.5 disable-thinking gap

Found during a final per-model audit round with independent 2-3 source
verification on every changed model:

- gpt-5.6-sol: restore 'max' reasoning-effort value. Multiple independent
  sources (OpenAI's own model-guidance docs page, launch announcement, and
  press coverage) confirm 'max' is a real, newly-launched value exclusive to
  Sol - not fabricated as originally assessed. Terra and Luna correctly do
  NOT get 'max' (confirmed Sol-exclusive), so they're unchanged.
- gemini-2.5-flash / gemini-2.5-flash-lite (google + vertex): selecting
  'none' for thinking level was sending no thinkingConfig at all, which
  falls back to the API's dynamic default (thinking stays ON for flash) -
  not actually disabling it, even though both models explicitly support
  thinkingBudget:0. Now sends an explicit budget of 0 for these two models
  specifically (gemini-2.5-pro is correctly excluded - it cannot disable
  thinking at all, floor is 128 not 0).

Author: waleedlatif1

apps/sim/providers/gemini/core.ts

@@ -26,6 +26,7 @@ import {
   extractTextContent,
   mapToThinkingBudget,
   mapToThinkingLevel,
+  supportsDisablingGemini25Thinking,
 } from '@/providers/google/utils'
 import { enrichLastModelSegment } from '@/providers/trace-enrichment'
 import type {
@@ -953,7 +954,7 @@ export async function executeGeminiRequest(
       )
     }
 
-    // Configure thinking only when the user explicitly selects a thinking level.
+    // Configure thinking based on the user's selected level.
     // Gemini 3.x accepts thinkingLevel directly; Gemini 2.5-series rejects thinkingLevel
     // entirely and requires a numeric thinkingBudget instead.
     if (request.thinkingLevel && request.thinkingLevel !== 'none') {
@@ -964,6 +965,14 @@ export async function executeGeminiRequest(
         thinkingConfig.thinkingBudget = mapToThinkingBudget(model, request.thinkingLevel)
       }
       geminiConfig.thinkingConfig = thinkingConfig
+    } else if (
+      request.thinkingLevel === 'none' &&
+      !isGemini3Model(model) &&
+      supportsDisablingGemini25Thinking(model)
+    ) {
+      // Omitting thinkingConfig entirely falls back to the API's own dynamic default, which
+      // is ON for gemini-2.5-flash — an explicit budget of 0 is required to actually disable it.
+      geminiConfig.thinkingConfig = { includeThoughts: false, thinkingBudget: 0 }
     }
 
     // Prepare tools

apps/sim/providers/google/utils.test.ts

@@ -6,6 +6,7 @@ import {
   convertToGeminiFormat,
   ensureStructResponse,
   mapToThinkingBudget,
+  supportsDisablingGemini25Thinking,
 } from '@/providers/google/utils'
 import type { ProviderRequest } from '@/providers/types'
 
@@ -42,6 +43,26 @@ describe('mapToThinkingBudget', () => {
   })
 })
 
+describe('supportsDisablingGemini25Thinking', () => {
+  it('returns true for gemini-2.5-flash and gemini-2.5-flash-lite', () => {
+    expect(supportsDisablingGemini25Thinking('gemini-2.5-flash')).toBe(true)
+    expect(supportsDisablingGemini25Thinking('gemini-2.5-flash-lite')).toBe(true)
+  })
+
+  it('returns false for gemini-2.5-pro, which cannot disable thinking', () => {
+    expect(supportsDisablingGemini25Thinking('gemini-2.5-pro')).toBe(false)
+  })
+
+  it('strips the vertex/ prefix before checking', () => {
+    expect(supportsDisablingGemini25Thinking('vertex/gemini-2.5-flash')).toBe(true)
+    expect(supportsDisablingGemini25Thinking('vertex/gemini-2.5-pro')).toBe(false)
+  })
+
+  it('returns false for models with no explicit mapping', () => {
+    expect(supportsDisablingGemini25Thinking('gemini-3.5-flash')).toBe(false)
+  })
+})
+
 describe('ensureStructResponse', () => {
   describe('should return objects unchanged', () => {
     it('should return plain object unchanged', () => {

apps/sim/providers/google/utils.ts

@@ -374,6 +374,23 @@ export function mapToThinkingBudget(model: string, level: string): number {
   return budgets[level.toLowerCase()] ?? budgets.high
 }
 
+/**
+ * Gemini 2.5-series models that accept `thinkingBudget: 0` to explicitly disable thinking.
+ * gemini-2.5-pro cannot disable thinking at all (its documented budget floor is 128, not 0),
+ * so it's deliberately excluded here.
+ */
+const GEMINI_25_MODELS_SUPPORTING_DISABLE = new Set(['gemini-2.5-flash', 'gemini-2.5-flash-lite'])
+
+/**
+ * Whether this Gemini 2.5-series model supports explicitly disabling thinking via budget=0.
+ * Omitting thinkingConfig entirely (the 'none' no-op path) falls back to the API's own
+ * dynamic default, which is ON for gemini-2.5-flash — not the same as actually disabling it.
+ */
+export function supportsDisablingGemini25Thinking(model: string): boolean {
+  const normalized = model.toLowerCase().replace(/^vertex\//, '')
+  return GEMINI_25_MODELS_SUPPORTING_DISABLE.has(normalized)
+}
+
 /**
  * Result of checking forced tool usage
  */

apps/sim/providers/models.ts

@@ -294,7 +294,7 @@ export const PROVIDER_DEFINITIONS: Record<string, ProviderDefinition> = {
         },
         capabilities: {
           reasoningEffort: {
-            values: ['none', 'low', 'medium', 'high', 'xhigh'],
+            values: ['none', 'low', 'medium', 'high', 'xhigh', 'max'],
           },
           verbosity: {
             values: ['low', 'medium', 'high'],