feat(models): gate forced tool use by model capability

Author: j15z

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/tool-input.tsx

@@ -80,6 +80,7 @@ import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
 import { useOperationAccess } from '@/hooks/use-operation-access'
 import { usePermissionConfig } from '@/hooks/use-permission-config'
 import { useSettingsNavigation } from '@/hooks/use-settings-navigation'
+import { supportsForcedToolUse } from '@/providers/models'
 import { getProviderFromModel, supportsToolUsageControl } from '@/providers/utils'
 import type { ActiveSearchTarget } from '@/stores/panel/editor/store'
 import { useSubBlockStore } from '@/stores/workflows/subblock/store'
@@ -561,10 +562,11 @@ export const ToolInput = memo(function ToolInput({
     })
   }, [mcpTools, mcpServers])
 
-  const modelValue = useSubBlockStore.getState().getValue(blockId, 'model')
+  const modelValue = useSubBlockStore((state) => state.getValue(blockId, 'model'))
   const model = typeof modelValue === 'string' ? modelValue : ''
   const provider = model ? getProviderFromModel(model) : ''
   const supportsToolControl = provider ? supportsToolUsageControl(provider) : false
+  const supportsForce = supportsForcedToolUse(model)
 
   const {
     filterBlocks,
@@ -1710,12 +1712,16 @@ export const ToolInput = memo(function ToolInput({
                         </PopoverItem>
                         <PopoverItem
                           active={tool.usageControl === 'force'}
+                          disabled={!supportsForce}
                           onClick={() => {
                             handleUsageControlChange(toolIndex, 'force')
                             setUsageControlPopoverIndex(null)
                           }}
                         >
-                          Force <span className='text-[var(--text-tertiary)]'>(always use)</span>
+                          Force{' '}
+                          <span className='text-[var(--text-tertiary)]'>
+                            {supportsForce ? '(always use)' : '(not supported by model)'}
+                          </span>
                         </PopoverItem>
                         <PopoverItem
                           active={tool.usageControl === 'none'}

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

@@ -296,8 +296,13 @@ describe('executeAnthropicProviderRequest forced tool use', () => {
     expect(payload.tool_choice).toEqual({ type: 'tool', name: 'publish' })
   })
 
-  it('drops forced tool_choice on Claude Fable 5.1 because the API rejects it', async () => {
-    const { payload, warn } = await runWithForcedTool('claude-fable-5-1')
+  it.each([
+    'claude-fable-5-1',
+    'claude-fable-5-1-20260901',
+    'azure-anthropic/claude-fable-5-1',
+    'claude-mythos-5-1',
+  ])('drops forced tool_choice on %s because the API rejects it', async (model) => {
+    const { payload, warn } = await runWithForcedTool(model)
     expect(payload.tools?.map((tool) => tool.name)).toEqual(['publish'])
     expect(payload).not.toHaveProperty('tool_choice')
     expect(warn).toHaveBeenCalledWith(expect.stringContaining('rejects forced tool_choice'))

apps/sim/providers/anthropic/core.ts

@@ -21,6 +21,7 @@ import {
 import {
   getMaxOutputTokensForModel,
   getThinkingCapability,
+  supportsForcedToolUse,
   supportsNativeStructuredOutputs,
   supportsTemperature,
 } from '@/providers/models'
@@ -155,17 +156,6 @@ function supportsAdaptiveThinking(modelId: string): boolean {
   )
 }
 
-/**
- * Claude Fable 5.1 and Claude Mythos 5.1 reject forced tool use: a `tool_choice` of
- * type `tool` or `any` returns a 400 (`tool_choice: type "tool" and "any" are not
- * supported for this model.`). Thinking is always on for these models, so a forced
- * call would skip it. The request is sent with the default `auto` instead.
- */
-function rejectsForcedToolChoice(modelId: string): boolean {
-  const normalizedModel = modelId.toLowerCase()
-  return normalizedModel.includes('fable-5-1') || normalizedModel.includes('mythos-5-1')
-}
-
 /**
  * Builds the thinking configuration for the Anthropic API based on model capabilities and level.
  *
@@ -428,7 +418,7 @@ export async function executeAnthropicProviderRequest(
     } else if (toolChoice === 'none') {
       payload.tool_choice = { type: 'none' }
     } else if (toolChoice !== 'auto') {
-      if (rejectsForcedToolChoice(request.model)) {
+      if (!supportsForcedToolUse(request.model)) {
         logger.warn(
           `Model ${modelId} rejects forced tool_choice; sending tool "${toolChoice.name}" with tool_choice auto`
         )

apps/sim/providers/models.test.ts

@@ -5,6 +5,7 @@ import { describe, expect, it } from 'vitest'
 import {
   getBaseModelProviders,
   getHostedModels,
+  getModelCapabilities,
   getModelPricing,
   getModelsWithPromptCaching,
   getPromptCachingMinimumTokens,
@@ -13,10 +14,40 @@ import {
   isModelDeprecated,
   orderModelIdsByReleaseDate,
   PROVIDER_DEFINITIONS,
+  supportsForcedToolUse,
   updateFireworksModels,
 } from '@/providers/models'
 import { supportsPromptCaching } from '@/providers/utils'
 
+describe('forced tool use capability', () => {
+  it('keeps Auto and None support when a model disables Force', () => {
+    expect(getModelCapabilities('claude-fable-5-1')).toMatchObject({
+      toolUsageControl: true,
+      forcedToolUse: false,
+    })
+  })
+
+  it.each([
+    'claude-fable-5-1',
+    'CLAUDE-FABLE-5-1-20260901',
+    'azure-anthropic/claude-fable-5-1',
+    'claude-mythos-5-1',
+  ])('disables forced tool use for %s', (model) => {
+    expect(supportsForcedToolUse(model)).toBe(false)
+  })
+
+  it.each(['claude-sonnet-5', 'claude-fable-5', 'claude-opus-5', 'gpt-5.5'])(
+    'inherits provider tool-control support for %s',
+    (model) => {
+      expect(supportsForcedToolUse(model)).toBe(true)
+    }
+  )
+
+  it('does not enable Force for an unknown model without tool-control capabilities', () => {
+    expect(supportsForcedToolUse('unknown-model')).toBe(false)
+  })
+})
+
 describe('Anthropic thinking stream visibility', () => {
   it('classifies visible Claude thinking as summarized rather than raw', () => {
     for (const providerId of ['anthropic', 'azure-anthropic'] as const) {

apps/sim/providers/models.ts

@@ -45,6 +45,8 @@ export interface ModelCapabilities {
     max: number
   }
   toolUsageControl?: boolean
+  /** Whether tools can be forced. Defaults to toolUsageControl when omitted. */
+  forcedToolUse?: boolean
   computerUse?: boolean
   nativeStructuredOutputs?: boolean
   /** Maximum supported output tokens for this model */
@@ -834,6 +836,7 @@ export const PROVIDER_DEFINITIONS: Record<string, ProviderDefinition> = {
           updatedAt: '2026-09-01',
         },
         capabilities: {
+          forcedToolUse: false,
           nativeStructuredOutputs: true,
           maxOutputTokens: 128000,
           promptCaching: { minimumCacheableTokens: 512 },
@@ -4391,6 +4394,20 @@ export function supportsToolUsageControl(providerId: string): boolean {
   return getProvidersWithToolUsageControl().includes(providerId)
 }
 
+/** Whether the model accepts forced tool choice, including uncataloged Claude aliases. */
+export function supportsForcedToolUse(modelId: string): boolean {
+  const capabilities = getModelCapabilities(modelId)
+  if (capabilities?.forcedToolUse !== undefined) return capabilities.forcedToolUse
+
+  /** Preserve the restriction for date-suffixed and reseller IDs outside the catalog. */
+  const normalizedModel = modelId.toLowerCase()
+  if (normalizedModel.includes('fable-5-1') || normalizedModel.includes('mythos-5-1')) {
+    return false
+  }
+
+  return capabilities?.toolUsageControl ?? false
+}
+
 export function updateOllamaModels(models: string[]): void {
   PROVIDER_DEFINITIONS.ollama.models = models.map((modelId) => ({
     id: modelId,