refactor(providers): drop the sanitizer's level diagnostics

The two warnings logged server-side, where the workflow author who set the level
never sees them, and the surprising case they described — a level discarded for
a model newer than the catalogue — is now fixed at the source rather than
narrated. They also carried the redaction that leaked resolved content before it
was caught, so removing them removes that surface entirely.

Levels still normalize, and still drop for a catalogued model that does not take
the field. `describeModelLevel` stays for Anthropic's unsupported-thinking
warning, which is a pre-existing log this feature newly exposes to resolved
reference content.

Author: waleedlatif1

apps/sim/providers/index.test.ts

@@ -4,32 +4,11 @@
 import { envFlagsMockFns, resetEnvFlagsMock } from '@sim/testing'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { mockGetApiKeyWithBYOK, mockExecuteRequest, mockLoggerWarn } = vi.hoisted(() => ({
+const { mockGetApiKeyWithBYOK, mockExecuteRequest } = vi.hoisted(() => ({
   mockGetApiKeyWithBYOK: vi.fn(),
   mockExecuteRequest: vi.fn(),
-  mockLoggerWarn: vi.fn(),
 }))
 
-/** Overrides the global logger mock so the sanitizer's warnings are assertable. */
-vi.mock('@sim/logger', () => {
-  const createLogger = () => ({
-    info: vi.fn(),
-    warn: mockLoggerWarn,
-    error: vi.fn(),
-    debug: vi.fn(),
-    trace: vi.fn(),
-    fatal: vi.fn(),
-    child: () => createLogger(),
-    withMetadata: () => createLogger(),
-  })
-  return {
-    createLogger,
-    logger: createLogger(),
-    runWithRequestContext: <T>(_ctx: unknown, fn: () => T): T => fn(),
-    getRequestContext: () => undefined,
-  }
-})
-
 vi.mock('@/lib/api-key/byok', () => ({
   getApiKeyWithBYOK: (...args: unknown[]) => mockGetApiKeyWithBYOK(...args),
 }))
@@ -550,95 +529,6 @@ describe('executeProviderRequest — model level normalization', () => {
     expect(sentRequest().verbosity).toBeUndefined()
   })
 
-  /**
-   * The model can itself be a reference, so it is only known at execution time. A run whose
-   * reference resolved to a model outside Sim's catalogue must not fall back to that model's
-   * default in silence.
-   */
-  it('reports the level it drops when the resolved model does not support the field', async () => {
-    await executeProviderRequest('anthropic', {
-      model: 'claude-opus-4-6',
-      workspaceId: 'ws-1',
-      reasoningEffort: 'high',
-    })
-
-    expect(mockLoggerWarn).toHaveBeenCalledWith(
-      'Model does not support this level; dropping it from the request',
-      expect.objectContaining({
-        field: 'reasoningEffort',
-        model: 'claude-opus-4-6',
-        value: 'high',
-      })
-    )
-  })
-
-  it('stays quiet when an unsupported model was never given a level', async () => {
-    await executeProviderRequest('anthropic', {
-      model: 'claude-opus-4-6',
-      workspaceId: 'ws-1',
-    })
-
-    expect(mockLoggerWarn).not.toHaveBeenCalled()
-  })
-
-  it('reports a level the model accepts but does not declare', async () => {
-    await executeProviderRequest('openai', {
-      model: 'gpt-5',
-      workspaceId: 'ws-1',
-      reasoningEffort: 'xhigh',
-    })
-
-    expect(mockLoggerWarn).toHaveBeenCalledWith(
-      'Model level is not one this model declares; forwarding to the provider',
-      expect.objectContaining({ field: 'reasoningEffort', model: 'gpt-5', value: 'xhigh' })
-    )
-  })
-
-  it('stays quiet for a declared level and for the auto and none sentinels', async () => {
-    await executeProviderRequest('openai', {
-      model: 'gpt-5',
-      workspaceId: 'ws-1',
-      reasoningEffort: 'auto',
-      verbosity: 'high',
-    })
-
-    expect(mockLoggerWarn).not.toHaveBeenCalled()
-  })
-
-  /**
-   * These fields take environment and block references, so a mistyped reference resolves the
-   * secret into the level. The diagnostics must never echo it.
-   */
-  it('redacts a level that is not a catalogue level before logging it', async () => {
-    const secret = 'sk-proj-abcdef0123456789'
-
-    await executeProviderRequest('openai', {
-      model: 'gpt-5',
-      workspaceId: 'ws-1',
-      reasoningEffort: secret,
-    })
-
-    expect(mockLoggerWarn).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.objectContaining({ value: `[redacted ${secret.length} chars]` })
-    )
-    const loggedText = JSON.stringify(mockLoggerWarn.mock.calls)
-    expect(loggedText).not.toContain(secret)
-  })
-
-  it('keeps the auto sentinel readable in a drop diagnostic', async () => {
-    await executeProviderRequest('anthropic', {
-      model: 'claude-opus-4-6',
-      workspaceId: 'ws-1',
-      reasoningEffort: 'auto',
-    })
-
-    expect(mockLoggerWarn).toHaveBeenCalledWith(
-      'Model does not support this level; dropping it from the request',
-      expect.objectContaining({ value: 'auto' })
-    )
-  })
-
   /**
    * A model the catalogue has never seen is unknown, not known-incapable — which is exactly
    * how a newly released model arrives through a reference before Sim catalogues it. The

apps/sim/providers/index.ts

@@ -15,20 +15,14 @@ import {
   attachLargeFileRemoteUrls,
   uploadLargeFilesToProvider,
 } from '@/providers/file-attachments.server'
-import {
-  getReasoningEffortValuesForModel,
-  getThinkingLevelsForModel,
-  getVerbosityValuesForModel,
-  isKnownModelId,
-} from '@/providers/models'
+import { isKnownModelId } from '@/providers/models'
 import { getProviderExecutor } from '@/providers/registry'
 import {
   type ProviderRuntimeContext,
   runWithProviderRuntimeContext,
 } from '@/providers/runtime-context'
 import type { ProviderId, ProviderRequest, ProviderResponse } from '@/providers/types'
 import {
-  describeModelLevel,
   generateStructuredOutputInstructions,
   sumToolCosts,
   supportsPromptCaching,
@@ -59,60 +53,6 @@ function normalizeModelLevel(value: string | undefined): string | undefined {
   return normalized || undefined
 }
 
-const MODEL_LEVEL_SENTINELS = new Set(['auto', 'none'])
-
-type ModelLevelField = 'reasoningEffort' | 'verbosity' | 'thinkingLevel'
-
-/**
- * Clears a level whose resolved model does not accept the field at all.
- *
- * Dropping is the safe default — a provider that has no such parameter rejects the whole
- * request — but the discard is reported because the model can be bound to a variable or block
- * reference and is therefore only known at execution time. Without this, a run whose reference
- * resolved to a model that does not take the field would quietly fall back to that model's
- * default while the caller believed the level applied.
- */
-function dropUnsupportedLevel(
-  field: ModelLevelField,
-  model: string,
-  value: string | undefined
-): undefined {
-  if (value) {
-    logger.warn('Model does not support this level; dropping it from the request', {
-      field,
-      model,
-      value: describeModelLevel(value),
-    })
-  }
-  return undefined
-}
-
-/**
- * Logs a level that the model accepts as a field but does not list as a value.
- *
- * 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: ModelLevelField,
-  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: describeModelLevel(value),
-    declaredValues,
-  })
-}
-
 function sanitizeRequest(request: ProviderRequest): ProviderRequest {
   const sanitizedRequest = { ...request }
   const model = sanitizedRequest.model
@@ -126,61 +66,31 @@ function sanitizeRequest(request: ProviderRequest): ProviderRequest {
   }
 
   /**
-   * A model absent from the catalogue is unknown, not known-incapable. Since the model can be
-   * bound to a reference, that is exactly how a newly released model arrives before Sim has
-   * catalogued it — so its levels are forwarded and the provider decides, rather than being
-   * discarded on the strength of a list that has not caught up. Models the catalogue does
-   * know, and every dynamic-provider id, keep the protective drop.
+   * A model absent from the catalogue is unknown, not known-incapable. The model field is an
+   * editable combobox, so a model newer than `models.ts` reaches this point routed by pattern
+   * and executing normally — discarding its levels on the strength of a list that has not
+   * caught up loses a setting the provider would have honoured. Those levels are forwarded and
+   * the provider decides. Models the catalogue does know, and every dynamic-provider id, keep
+   * the protective drop.
    */
   const isCatalogued = Boolean(model) && isKnownModelId(model)
 
   if (model && isCatalogued && !supportsReasoningEffort(model)) {
-    sanitizedRequest.reasoningEffort = dropUnsupportedLevel(
-      'reasoningEffort',
-      model,
-      sanitizedRequest.reasoningEffort
-    )
+    sanitizedRequest.reasoningEffort = undefined
   }
 
   if (model && isCatalogued && !supportsVerbosity(model)) {
-    sanitizedRequest.verbosity = dropUnsupportedLevel(
-      'verbosity',
-      model,
-      sanitizedRequest.verbosity
-    )
+    sanitizedRequest.verbosity = undefined
   }
 
   if (model && isCatalogued && !supportsThinking(model)) {
-    sanitizedRequest.thinkingLevel = dropUnsupportedLevel(
-      'thinkingLevel',
-      model,
-      sanitizedRequest.thinkingLevel
-    )
+    sanitizedRequest.thinkingLevel = undefined
   }
 
   if (model && !supportsPromptCaching(model)) {
     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
 }