improvement(agent): allow variable references in thinking level

Extends the same treatment to Thinking Level so all three model-tuning fields
behave consistently, and logs a level a model does not declare.

- switch `thinkingLevel` to `combobox` with the reference-aware condition
- normalize it alongside the other two; an empty resolve now takes the
  deliberate "send nothing" path rather than the incoherent half-state it hit
  before, and stays distinct from an explicit `none`
- warn when a level is not one the model declares, still forwarding it: Sim's
  per-model lists drive the pickers and can lag a provider, and a sweep needs
  the provider's own error rather than a silent fallback to the default

Author: waleedlatif1

apps/sim/blocks/blocks.test.ts

@@ -843,10 +843,17 @@ describe.concurrent('Blocks Module', () => {
       expect(modelSubBlock?.commandSearchable).toBe(true)
     })
 
-    it('should let the agent reasoning and verbosity fields take a typed reference', () => {
+    /** Each model-tuning field with a model that accepts it and one that does not. */
+    const AGENT_MODEL_LEVEL_FIELDS = [
+      { id: 'reasoningEffort', capable: 'gpt-5.1', incapable: 'claude-sonnet-5' },
+      { id: 'verbosity', capable: 'gpt-5.1', incapable: 'claude-sonnet-5' },
+      { id: 'thinkingLevel', capable: 'claude-sonnet-5', incapable: 'gpt-5.1' },
+    ] as const
+
+    it('should let the agent model-tuning fields take a typed reference', () => {
       const agentBlock = getBlock('agent')
 
-      for (const id of ['reasoningEffort', 'verbosity']) {
+      for (const { id } of AGENT_MODEL_LEVEL_FIELDS) {
         const subBlock = agentBlock?.subBlocks.find((sb) => sb.id === id)
         // A combobox is editable, so a `<block.output>` / `{{ENV_VAR}}` reference can be
         // typed into it; the option list still offers every level the model accepts.
@@ -855,18 +862,19 @@ describe.concurrent('Blocks Module', () => {
       }
     })
 
-    it('should keep the agent reasoning and verbosity fields visible when the model is a reference', () => {
+    it('should keep the agent model-tuning fields visible when the model is a reference', () => {
       const agentBlock = getBlock('agent')
 
-      for (const id of ['reasoningEffort', 'verbosity']) {
+      for (const { id, capable, incapable } of AGENT_MODEL_LEVEL_FIELDS) {
         const subBlock = agentBlock?.subBlocks.find((sb) => sb.id === id)
         const condition = subBlock?.condition
         if (typeof condition !== 'function') throw new Error(`${id} condition is not a function`)
 
         expect(evaluateSubBlockCondition(condition, { model: '<start.model>' })).toBe(true)
         expect(evaluateSubBlockCondition(condition, { model: '{{MODEL_ID}}' })).toBe(true)
-        expect(evaluateSubBlockCondition(condition, { model: 'gpt-5.1' })).toBe(true)
-        expect(evaluateSubBlockCondition(condition, { model: 'claude-sonnet-5' })).toBe(false)
+        // Gating on the capability list is unchanged for a literal model.
+        expect(evaluateSubBlockCondition(condition, { model: capable })).toBe(true)
+        expect(evaluateSubBlockCondition(condition, { model: incapable })).toBe(false)
       }
     })
 

apps/sim/blocks/blocks/agent.ts

@@ -266,8 +266,8 @@ Return ONLY the JSON array.`,
     {
       id: 'thinkingLevel',
       title: 'Thinking Level',
-      type: 'dropdown',
-      placeholder: 'Select thinking level...',
+      type: 'combobox',
+      placeholder: 'Type or select thinking level...',
       options: [
         { label: 'none', id: 'none' },
         { label: 'minimal', id: 'minimal' },
@@ -301,10 +301,7 @@ Return ONLY the JSON array.`,
         return [noneOption, ...validOptions.map((opt) => ({ label: opt, id: opt }))]
       },
       mode: 'advanced',
-      condition: {
-        field: 'model',
-        value: MODELS_WITH_THINKING,
-      },
+      condition: getModelCapabilityCondition(MODELS_WITH_THINKING),
     },
     {
       id: 'promptCaching',

apps/sim/providers/index.test.ts

@@ -414,9 +414,9 @@ describe('executeProviderRequest — streaming cost policy', () => {
 })
 
 /**
- * `reasoningEffort` and `verbosity` can be bound to a variable or block reference in the
- * agent block, so by the time they reach the provider they hold whatever that reference
- * resolved to rather than a value picked from a list.
+ * `reasoningEffort`, `verbosity`, and `thinkingLevel` can be bound to a variable or block
+ * reference in the agent block, so by the time they reach the provider they hold whatever
+ * that reference resolved to rather than a value picked from a list.
  */
 describe('executeProviderRequest — model level normalization', () => {
   beforeEach(() => {
@@ -443,6 +443,16 @@ describe('executeProviderRequest — model level normalization', () => {
     expect(sentRequest().verbosity).toBe('low')
   })
 
+  it('trims and lower-cases a thinking level a reference resolved to', async () => {
+    await executeProviderRequest('anthropic', {
+      model: 'claude-sonnet-5',
+      workspaceId: 'ws-1',
+      thinkingLevel: ' High ',
+    })
+
+    expect(sentRequest().thinkingLevel).toBe('high')
+  })
+
   it('treats a level that resolved to nothing as unset rather than an empty string', async () => {
     await executeProviderRequest('openai', {
       model: 'gpt-5',
@@ -455,6 +465,30 @@ describe('executeProviderRequest — model level normalization', () => {
     expect(sentRequest().verbosity).toBeUndefined()
   })
 
+  /**
+   * Providers treat an explicit `'none'` as "thinking off" and an absent value as "send
+   * nothing", so a reference that resolved to nothing must land on the latter.
+   */
+  it('treats a thinking level that resolved to nothing as unset, not as none', async () => {
+    await executeProviderRequest('anthropic', {
+      model: 'claude-sonnet-5',
+      workspaceId: 'ws-1',
+      thinkingLevel: '  ',
+    })
+
+    expect(sentRequest().thinkingLevel).toBeUndefined()
+  })
+
+  it('preserves an explicit none thinking level', async () => {
+    await executeProviderRequest('anthropic', {
+      model: 'claude-sonnet-5',
+      workspaceId: 'ws-1',
+      thinkingLevel: 'none',
+    })
+
+    expect(sentRequest().thinkingLevel).toBe('none')
+  })
+
   it('leaves an already-valid level untouched', async () => {
     await executeProviderRequest('openai', {
       model: 'gpt-5',
@@ -467,6 +501,22 @@ describe('executeProviderRequest — model level normalization', () => {
     expect(sentRequest().verbosity).toBe('high')
   })
 
+  /**
+   * Sim's per-model level lists drive the pickers and can lag a provider that has started
+   * accepting a new level, so an unrecognized level is forwarded rather than dropped: the
+   * provider answers with an error naming the values it accepts, instead of Sim silently
+   * substituting the model default and quietly corrupting a sweep.
+   */
+  it('forwards a level the model does not declare so the provider reports it', async () => {
+    await executeProviderRequest('openai', {
+      model: 'gpt-5',
+      workspaceId: 'ws-1',
+      reasoningEffort: 'xhigh',
+    })
+
+    expect(sentRequest().reasoningEffort).toBe('xhigh')
+  })
+
   it('still drops levels the resolved model does not support', async () => {
     await executeProviderRequest('anthropic', {
       model: 'claude-opus-4-6',

apps/sim/providers/index.ts

@@ -15,6 +15,11 @@ import {
   attachLargeFileRemoteUrls,
   uploadLargeFilesToProvider,
 } from '@/providers/file-attachments.server'
+import {
+  getReasoningEffortValuesForModel,
+  getThinkingLevelsForModel,
+  getVerbosityValuesForModel,
+} from '@/providers/models'
 import { getProviderExecutor } from '@/providers/registry'
 import {
   type ProviderRuntimeContext,
@@ -52,12 +57,46 @@ function normalizeModelLevel(value: string | undefined): string | undefined {
   return normalized || undefined
 }
 
+/**
+ * Levels the pickers offer on top of what a model declares. `auto` means "say nothing" and
+ * `none` means "explicitly off"; every provider adapter special-cases them, so neither is
+ * an unrecognized level.
+ */
+const MODEL_LEVEL_SENTINELS = new Set(['auto', 'none'])
+
+/**
+ * Logs a level that is not one the model declares.
+ *
+ * Deliberately does not drop the value. Sim's per-model level lists exist to populate the
+ * pickers and can lag a provider that has started accepting a new level, so rejecting on them
+ * would refuse values the API would have taken. Forwarding instead surfaces the provider's own
+ * error, which names the field and the values it accepts — the loud failure an eval sweeping
+ * levels needs, where silently substituting the model default would corrupt the results.
+ */
+function warnOnUnrecognizedLevel(
+  field: 'reasoningEffort' | 'verbosity' | 'thinkingLevel',
+  model: string | undefined,
+  value: string | undefined,
+  declaredValues: string[] | null
+): void {
+  if (!model || !value || MODEL_LEVEL_SENTINELS.has(value)) return
+  if (!declaredValues || declaredValues.includes(value)) return
+
+  logger.warn('Model level is not one this model declares; forwarding to the provider', {
+    field,
+    model,
+    value,
+    declaredValues,
+  })
+}
+
 function sanitizeRequest(request: ProviderRequest): ProviderRequest {
   const sanitizedRequest = { ...request }
   const model = sanitizedRequest.model
 
   sanitizedRequest.reasoningEffort = normalizeModelLevel(sanitizedRequest.reasoningEffort)
   sanitizedRequest.verbosity = normalizeModelLevel(sanitizedRequest.verbosity)
+  sanitizedRequest.thinkingLevel = normalizeModelLevel(sanitizedRequest.thinkingLevel)
 
   if (model && !supportsTemperature(model)) {
     sanitizedRequest.temperature = undefined
@@ -79,6 +118,25 @@ function sanitizeRequest(request: ProviderRequest): ProviderRequest {
     sanitizedRequest.promptCaching = undefined
   }
 
+  warnOnUnrecognizedLevel(
+    'reasoningEffort',
+    model,
+    sanitizedRequest.reasoningEffort,
+    model ? getReasoningEffortValuesForModel(model) : null
+  )
+  warnOnUnrecognizedLevel(
+    'verbosity',
+    model,
+    sanitizedRequest.verbosity,
+    model ? getVerbosityValuesForModel(model) : null
+  )
+  warnOnUnrecognizedLevel(
+    'thinkingLevel',
+    model,
+    sanitizedRequest.thinkingLevel,
+    model ? getThinkingLevelsForModel(model) : null
+  )
+
   return sanitizedRequest
 }