fix(tool-input): address review round 2 — enum shape and legacy MCP arg values

- `getJsonSchemaValueShape` checked the enum branch before the declared type, so
  `{ type: 'integer', enum: [1,2,3] }` was shaped as text. The dropdown it renders
  as stores `String(option)`, so the server received '1' instead of 1. The
  declared type now wins, and an untyped enum is inferred from its members.
- An MCP argument entered before its control was derived from the NORMALIZED
  schema type is stored as a string, so a union-typed boolean's 'false' would
  tick the switch it now renders as. `mcp-dynamic-args` decodes on read; already
  typed values pass through, so it is a no-op thereafter.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: icecrasher321

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/mcp-dynamic-args/mcp-dynamic-args.tsx

@@ -12,6 +12,8 @@ import { useActiveSearchTarget } from '@/app/workspace/[workspaceId]/w/[workflow
 import type { SubBlockConfig } from '@/blocks/types'
 import { useMcpTools } from '@/hooks/mcp/use-mcp-tools'
 import {
+  decodeToolParamValue,
+  getJsonSchemaValueShape,
   type JsonSchemaProperty,
   jsonSchemaType,
   subBlockTypeForJsonSchema,
@@ -235,7 +237,11 @@ export function McpDynamicArgs({
 
   const renderParameterInput = (paramName: string, paramSchema: any) => {
     const current = currentArgs()
-    const value = current[paramName]
+    // An argument entered before this control was derived from the NORMALIZED schema type
+    // was collected by a text field, so it is stored as a string — `'false'` would tick the
+    // switch it now renders as. Decoding on read normalizes it to the shape the control
+    // expects; already-typed values pass through untouched, so this is a no-op thereafter.
+    const value = decodeToolParamValue(current[paramName], getJsonSchemaValueShape(paramSchema))
     const inputType = getInputType(paramSchema)
 
     switch (inputType) {
@@ -262,6 +268,9 @@ export function McpDynamicArgs({
           label: String(option),
           value: String(option),
         }))
+        // Options are stringified members, so a decoded numeric/boolean enum value has to
+        // be stringified back to match one.
+        const dropdownValue = value === undefined || value === null ? '' : String(value)
         const selectedLabel = value ? String(value) : ''
         const workflowSearchHighlight = getWorkflowSearchLabelHighlight({
           activeSearchTarget,
@@ -275,8 +284,8 @@ export function McpDynamicArgs({
           <div key={`${paramName}-dropdown`}>
             <Combobox
               options={dropdownOptions}
-              value={value || ''}
-              selectedValue={value || ''}
+              value={dropdownValue}
+              selectedValue={dropdownValue}
               onChange={(selectedValue) => {
                 const matchedOption = dropdownOptions.find(
                   (opt: { label: string; value: string }) => opt.value === selectedValue

apps/sim/tools/param-shape.test.ts

@@ -11,6 +11,7 @@ import {
   decodeToolParamValue,
   encodeToolParamValue,
   expandSubBlockValueToParams,
+  getJsonSchemaValueShape,
   getSubBlockValueShape,
   getToolParamValueShape,
   subBlockTypeForValueType,
@@ -512,12 +513,55 @@ describe('buildJsonSchemaParamShapes', () => {
     expect(controls.get('nullableInt')).toBe('slider')
   })
 
-  it('treats a structured enum as JSON and a primitive one as text', () => {
+  it('reads an enum from its declared type before its members', () => {
+    // A dropdown stores `String(option)`, so a numeric enum read as text would send
+    // '1' where the server expects 1.
     const shapes = buildJsonSchemaParamShapes({
-      properties: { structured: { enum: [{ a: 1 }] }, primitive: { enum: ['x', 'y'] } },
+      properties: {
+        declaredInt: { type: 'integer', enum: [1, 2, 3] },
+        declaredBool: { type: 'boolean', enum: [true, false] },
+        declaredStr: { type: 'string', enum: ['a', 'b'] },
+      },
     })
 
+    expect(shapes.get('declaredInt')).toBe('number')
+    expect(shapes.get('declaredBool')).toBe('boolean')
+    expect(shapes.get('declaredStr')).toBe('string')
+  })
+
+  it('infers an untyped enum from its members', () => {
+    const shapes = buildJsonSchemaParamShapes({
+      properties: {
+        nums: { enum: [1, 2] },
+        bools: { enum: [true, false] },
+        strs: { enum: ['x', 'y'] },
+        structured: { enum: [{ a: 1 }] },
+        mixed: { enum: [1, 'x'] },
+      },
+    })
+
+    expect(shapes.get('nums')).toBe('number')
+    expect(shapes.get('bools')).toBe('boolean')
+    expect(shapes.get('strs')).toBe('string')
     expect(shapes.get('structured')).toBe('json')
-    expect(shapes.get('primitive')).toBe('string')
+    expect(shapes.get('mixed')).toBe('string')
+  })
+
+  it('round-trips a numeric enum through the dropdown it renders as', () => {
+    const property = { type: 'integer', enum: [1, 2, 3] }
+    const [subBlock] = buildSubBlocksFromJsonSchema({ properties: { n: property } }, (id) => id)
+
+    expect(subBlock.type).toBe('dropdown')
+    // The dropdown stores the stringified member; the shape decodes it back.
+    expect(decodeToolParamValue('2', getJsonSchemaValueShape(property))).toBe(2)
+  })
+
+  it('normalizes a legacy string left by a control that has since changed type', () => {
+    // A union-typed property used to render as a text field and now renders as a switch;
+    // its stored 'false' must not tick the box.
+    expect(
+      decodeToolParamValue('false', getJsonSchemaValueShape({ type: ['boolean', 'null'] }))
+    ).toBe(false)
+    expect(decodeToolParamValue(true, getJsonSchemaValueShape({ type: 'boolean' }))).toBe(true)
   })
 })

apps/sim/tools/param-shape.ts

@@ -409,17 +409,26 @@ export function subBlockTypeForJsonSchema(property: JsonSchemaProperty): SubBloc
  * the control would answer `'string'` and the argument would reach the MCP server
  * undecoded. The same holds for a non-primitive enum, which renders as free text.
  */
-function getJsonSchemaValueShape(property: JsonSchemaProperty): ToolParamValueShape {
-  if (Array.isArray(property.enum)) {
-    return property.enum.every((option) => option === null || typeof option !== 'object')
-      ? 'string'
-      : 'json'
-  }
-
+export function getJsonSchemaValueShape(property: JsonSchemaProperty): ToolParamValueShape {
   const type = jsonSchemaType(property)
   if (type === 'boolean') return 'boolean'
   if (type === 'number' || type === 'integer') return 'number'
   if (type === 'object' || type === 'array') return 'json'
+  if (type === 'string') return 'string'
+
+  // No declared type leaves the enum members as the only signal. This runs AFTER the
+  // declared type, not before: a dropdown stores `String(option)`, so a numeric enum
+  // read as text would send `'1'` where the server expects `1`.
+  if (Array.isArray(property.enum)) return enumMemberShape(property.enum)
+
+  return 'string'
+}
+
+/** The shape an enum's members share, for a property that declares no type. */
+function enumMemberShape(members: readonly unknown[]): ToolParamValueShape {
+  if (members.some((member) => member !== null && typeof member === 'object')) return 'json'
+  if (members.every((member) => typeof member === 'number')) return 'number'
+  if (members.every((member) => typeof member === 'boolean')) return 'boolean'
   return 'string'
 }