fix(providers): redact the level in Anthropic's unsupported-thinking warning

Forwarding an undeclared level is deliberate, but it means the Anthropic adapter
receives it and interpolates it straight into its "not supported, ignoring"
warning. Since the field is reference-bound, that value can be whatever a
mistyped `{{ENV_VAR}}` or block reference resolved to — so the redaction added
for the sanitizer's own diagnostics was leaking one layer downstream.

- promote the level renderer to `providers/utils` as `describeModelLevel`, the
  single gate every site echoing a caller-supplied level goes through
- use it in Anthropic's warning and in both sanitizer diagnostics

Author: waleedlatif1

apps/sim/providers/anthropic/core.thinking.test.ts

@@ -8,6 +8,7 @@
  */
 import { describe, expect, it } from 'vitest'
 import { buildThinkingConfig } from '@/providers/anthropic/core'
+import { describeModelLevel } from '@/providers/utils'
 
 describe('buildThinkingConfig', () => {
   it('requests summarized display for omitted-display models on agent-events runs', () => {
@@ -55,3 +56,21 @@ describe('buildThinkingConfig', () => {
     expect(buildThinkingConfig('gpt-4o', 'high', true)).toBeNull()
   })
 })
+
+/**
+ * A thinking level that is not one the model declares reaches this adapter, by design — Sim's
+ * per-model lists can lag a provider. The adapter logs that it is ignoring it, and since the
+ * field is reference-bound, the value it logs can be whatever a mistyped `{{ENV_VAR}}` or block
+ * reference resolved to.
+ */
+describe('unsupported thinking level logging', () => {
+  it('returns null for a level the model does not declare', () => {
+    expect(buildThinkingConfig('claude-sonnet-5', 'sk-proj-abcdef0123456789', false)).toBeNull()
+  })
+
+  it('redacts the level in the ignore warning instead of echoing it', () => {
+    const secret = 'sk-proj-abcdef0123456789'
+    expect(describeModelLevel(secret)).toBe(`[redacted ${secret.length} chars]`)
+    expect(describeModelLevel('high')).toBe('high')
+  })
+})

apps/sim/providers/anthropic/core.ts

@@ -31,7 +31,11 @@ import { adaptAnthropicToolSchema } from '@/providers/tool-schema-adapter'
 import { enrichLastModelSegment } from '@/providers/trace-enrichment'
 import type { ProviderRequest, ProviderResponse, TimeSegment } from '@/providers/types'
 import { ProviderError } from '@/providers/types'
-import { prepareToolExecution, prepareToolsWithUsageControl } from '@/providers/utils'
+import {
+  describeModelLevel,
+  prepareToolExecution,
+  prepareToolsWithUsageControl,
+} from '@/providers/utils'
 
 /**
  * Configuration for creating an Anthropic provider instance.
@@ -396,7 +400,7 @@ export async function executeAnthropicProviderRequest(
       )
     } else {
       logger.warn(
-        `Thinking level "${request.thinkingLevel}" not supported for model: ${modelId}, ignoring`
+        `Thinking level "${describeModelLevel(request.thinkingLevel)}" not supported for model: ${modelId}, ignoring`
       )
     }
   }

apps/sim/providers/index.ts

@@ -20,7 +20,6 @@ import {
   getThinkingLevelsForModel,
   getVerbosityValuesForModel,
   isKnownModelId,
-  isKnownModelLevelValue,
 } from '@/providers/models'
 import { getProviderExecutor } from '@/providers/registry'
 import {
@@ -29,6 +28,7 @@ import {
 } from '@/providers/runtime-context'
 import type { ProviderId, ProviderRequest, ProviderResponse } from '@/providers/types'
 import {
+  describeModelLevel,
   generateStructuredOutputInstructions,
   sumToolCosts,
   supportsPromptCaching,
@@ -59,28 +59,10 @@ 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'])
 
 type ModelLevelField = 'reasoningEffort' | 'verbosity' | 'thinkingLevel'
 
-/**
- * Renders a level for a log line.
- *
- * These fields accept variable and environment references, so an unrecognized value is not
- * necessarily a mistyped level — it is whatever the reference resolved to, which may be secret
- * content. Only a level the catalogue declares somewhere is safe to echo; anything else is
- * reported by length alone, which is enough to tell a stray level from a resolved blob.
- */
-function describeLevel(value: string): string {
-  const isSafe = MODEL_LEVEL_SENTINELS.has(value) || isKnownModelLevelValue(value)
-  return isSafe ? value : `[redacted ${value.length} chars]`
-}
-
 /**
  * Clears a level whose resolved model does not accept the field at all.
  *
@@ -99,7 +81,7 @@ function dropUnsupportedLevel(
     logger.warn('Model does not support this level; dropping it from the request', {
       field,
       model,
-      value: describeLevel(value),
+      value: describeModelLevel(value),
     })
   }
   return undefined
@@ -126,7 +108,7 @@ function warnOnUnrecognizedLevel(
   logger.warn('Model level is not one this model declares; forwarding to the provider', {
     field,
     model,
-    value: describeLevel(value),
+    value: describeModelLevel(value),
     declaredValues,
   })
 }

apps/sim/providers/utils.test.ts

@@ -2,6 +2,7 @@ import { resetEnvFlagsMock, setEnvFlags } from '@sim/testing'
 import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   calculateCost,
+  describeModelLevel,
   extractAndParseJSON,
   filterBlacklistedModels,
   formatCost,
@@ -1767,3 +1768,32 @@ describe('prepareToolExecution invoker identity hand-off', () => {
     expect(executionParams._context.executionId).toBeUndefined()
   })
 })
+
+/**
+ * The agent block's tuning-level fields accept variable and environment references, so any
+ * message that echoes a caller-supplied level can otherwise carry whatever that reference
+ * resolved to — including secret content.
+ */
+describe('describeModelLevel', () => {
+  it('echoes a level the catalogue declares', () => {
+    expect(describeModelLevel('high')).toBe('high')
+    expect(describeModelLevel('minimal')).toBe('minimal')
+    expect(describeModelLevel('xhigh')).toBe('xhigh')
+  })
+
+  it('echoes the auto and none sentinels', () => {
+    expect(describeModelLevel('auto')).toBe('auto')
+    expect(describeModelLevel('none')).toBe('none')
+  })
+
+  it('redacts anything else to a length', () => {
+    const secret = 'sk-proj-abcdef0123456789'
+    expect(describeModelLevel(secret)).toBe(`[redacted ${secret.length} chars]`)
+    expect(describeModelLevel(secret)).not.toContain('abcdef')
+  })
+
+  it('reports an absent level without throwing', () => {
+    expect(describeModelLevel(undefined)).toBe('(unset)')
+    expect(describeModelLevel('')).toBe('(unset)')
+  })
+})

apps/sim/providers/utils.ts

@@ -44,6 +44,7 @@ import {
   getReasoningEffortValuesForModel as getReasoningEffortValuesForModelFromDefinitions,
   getThinkingLevelsForModel as getThinkingLevelsForModelFromDefinitions,
   getVerbosityValuesForModel as getVerbosityValuesForModelFromDefinitions,
+  isKnownModelLevelValue,
   PROVIDER_DEFINITIONS,
   supportsTemperature as supportsTemperatureFromDefinitions,
   supportsToolUsageControl as supportsToolUsageControlFromDefinitions,
@@ -1381,6 +1382,30 @@ export function supportsTemperature(model: string): boolean {
   return supportsTemperatureFromDefinitions(model)
 }
 
+/**
+ * Levels the pickers offer on top of what a model declares. `auto` means "say nothing" and
+ * `none` means "explicitly off"; provider adapters special-case both, so neither is an
+ * unrecognized level.
+ */
+const MODEL_LEVEL_SENTINELS = new Set(['auto', 'none'])
+
+/**
+ * Renders a tuning level for a log line or an error message.
+ *
+ * The agent block's reasoning effort, verbosity, and thinking level fields accept variable and
+ * environment references, so an unrecognized level is not necessarily a mistyped level — it is
+ * whatever the reference resolved to, up to and including secret content. Only a level the
+ * catalogue declares somewhere is safe to echo; anything else is reported by length alone,
+ * which still distinguishes a stray level from a resolved blob.
+ *
+ * Every site that puts a caller-supplied level into a message must go through this.
+ */
+export function describeModelLevel(value: string | undefined): string {
+  if (!value) return '(unset)'
+  const isSafe = MODEL_LEVEL_SENTINELS.has(value) || isKnownModelLevelValue(value)
+  return isSafe ? value : `[redacted ${value.length} chars]`
+}
+
 export function supportsReasoningEffort(model: string): boolean {
   return MODELS_WITH_REASONING_EFFORT.includes(model.toLowerCase())
 }