revert(mcp): drop the enum-member recovery layer

Checked against the prod replica rather than reasoning about it, and every
case this guarded has zero instances:

- `workflow_mcp_tool`: 470 properties, 0 declare an `enum` at all.
- MCP blocks' cached `_toolSchema`: 6 enums, all `type: 'string'` with string
  members. No untyped enum, no `null`/number/boolean member.
- Stored MCP block arguments (179): 0 stringified booleans, 0 stringified
  nulls. Booleans and numbers are already persisted with their real types.
- Agent MCP tool-row params (10,022): 0 stringified booleans, 0 stringified
  nulls, 4 stringified numbers — already covered by the `type: number`
  coercion that predates this branch.

For a string enum `String(member) === value` returns the same string, so the
whole path was a no-op on every row in production while adding a coercion at
an authorized use case plus a validation widening to keep that coercion safe.
The dropdown already persists the member (679325a), so nothing downstream
has to reverse the encoding.

`enumMemberShape` goes with it — every real enum declares a type, so member
inference never runs. The declared-type-first ordering stays: it is a
precedence fix, not a layer. `getJsonSchemaValueShape` is private again.

`lib/mcp/application/execute-tool.ts` is byte-identical to 679325a.

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,7 +12,6 @@ import { useActiveSearchTarget } from '@/app/workspace/[workspaceId]/w/[workflow
 import type { SubBlockConfig } from '@/blocks/types'
 import { useMcpTools } from '@/hooks/mcp/use-mcp-tools'
 import {
-  decodeJsonSchemaValue,
   type JsonSchemaProperty,
   jsonSchemaType,
   subBlockTypeForJsonSchema,
@@ -236,13 +235,7 @@ export function McpDynamicArgs({
 
   const renderParameterInput = (paramName: string, paramSchema: any) => {
     const current = currentArgs()
-    // 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.
-    // This is the same decode `coerceToolArguments` applies at execution, so the control
-    // shows what the server will actually receive.
-    const value = decodeJsonSchemaValue(current[paramName], paramSchema)
+    const value = current[paramName]
     const inputType = getInputType(paramSchema)
 
     switch (inputType) {

apps/sim/lib/mcp/application/execute-tool.test.ts

@@ -160,95 +160,6 @@ describe('executeMcpToolUseCase', () => {
     expect(mocks.telemetry).toHaveBeenCalledOnce()
   })
 
-  it('recovers enum members a dropdown stored as their stringified form', async () => {
-    // The editor's dropdown option ids are `String(member)`, so an argument saved before
-    // that control persisted real members holds text. Only the member list inverts it —
-    // the declared-type branches cannot tell `'null'` the text from `null` the member.
-    mocks.discoverServerTools.mockResolvedValueOnce([
-      {
-        name: 'lookup',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            mode: { type: 'string', enum: ['fast', null] },
-            level: { enum: [1, 2, 3] },
-            verbose: { type: 'boolean', enum: [true, false] },
-          },
-        },
-      },
-    ])
-
-    await executeMcpToolUseCase.execute({
-      principal: PRINCIPAL,
-      input: {
-        workspaceId: WORKSPACE.workspaceId,
-        serverId: SERVER.id,
-        toolName: 'lookup',
-        arguments: { mode: 'null', level: '2', verbose: 'false' },
-      },
-    })
-
-    expect(mocks.executeTool).toHaveBeenCalledWith(
-      'user-1',
-      SERVER.id,
-      { name: 'lookup', arguments: { mode: null, level: 2, verbose: false } },
-      WORKSPACE.workspaceId,
-      undefined,
-      undefined,
-      expect.anything()
-    )
-  })
-
-  it('accepts a declared enum member that satisfies no declared-type branch', async () => {
-    // `mode` declares `type: 'string'`, so a recovered `null` member would fail every
-    // type check. The enum is narrower than the type and decides on its own.
-    mocks.discoverServerTools.mockResolvedValueOnce([
-      {
-        name: 'lookup',
-        inputSchema: {
-          type: 'object',
-          properties: { mode: { type: 'string', enum: ['fast', null] } },
-        },
-      },
-    ])
-
-    await expect(
-      executeMcpToolUseCase.execute({
-        principal: PRINCIPAL,
-        input: {
-          workspaceId: WORKSPACE.workspaceId,
-          serverId: SERVER.id,
-          toolName: 'lookup',
-          arguments: { mode: null },
-        },
-      })
-    ).resolves.toMatchObject({ success: true })
-  })
-
-  it('still rejects a value the schema does not allow', async () => {
-    mocks.discoverServerTools.mockResolvedValueOnce([
-      {
-        name: 'lookup',
-        inputSchema: {
-          type: 'object',
-          properties: { mode: { type: 'string', enum: ['fast', null] } },
-        },
-      },
-    ])
-
-    await expect(
-      executeMcpToolUseCase.execute({
-        principal: PRINCIPAL,
-        input: {
-          workspaceId: WORKSPACE.workspaceId,
-          serverId: SERVER.id,
-          toolName: 'lookup',
-          arguments: { mode: 42 },
-        },
-      })
-    ).rejects.toMatchObject({ code: 'validation' })
-  })
-
   it('rejects foreign or missing servers before permission and provider work', async () => {
     mocks.getServer.mockResolvedValueOnce(null)
 

apps/sim/lib/mcp/application/execute-tool.ts

@@ -16,11 +16,6 @@ import {
   McpToolsNotAllowedError,
 } from '@/ee/access-control/utils/permission-check'
 import type { ResolvedSecretTraceProvenanceV1 } from '@/executor/utils/resolved-secret-trace-registry'
-import {
-  jsonSchemaEnumMember,
-  jsonSchemaEnumMembers,
-  jsonSchemaProperties,
-} from '@/tools/param-shape'
 
 const logger = createLogger('McpToolExecution')
 
@@ -52,22 +47,13 @@ function coerceToolArguments(
   input: Record<string, unknown>
 ): Record<string, unknown> {
   const result = { ...input }
+  if (!tool.inputSchema?.properties) return result
 
-  for (const [name, property] of jsonSchemaProperties(tool.inputSchema)) {
+  for (const [name, property] of Object.entries(tool.inputSchema.properties)) {
+    if (!hasType(property)) continue
     const value = result[name]
     if (value === undefined || value === null) continue
 
-    // An enum renders as a dropdown whose option ids are `String(member)`. Only the
-    // member list inverts that, and it has to run before the declared-type branches
-    // below, which never see an untyped property and cannot recover a `null` member.
-    const member = jsonSchemaEnumMember(value, property)
-    if (member !== undefined) {
-      result[name] = member
-      continue
-    }
-
-    if (!hasType(property)) continue
-
     if ((property.type === 'number' || property.type === 'integer') && typeof value === 'string') {
       const numberValue =
         property.type === 'integer' ? Number.parseInt(value) : Number.parseFloat(value)
@@ -112,14 +98,9 @@ function validateToolArguments(tool: McpTool, args: Record<string, unknown>): vo
     }
   }
 
-  for (const [name, property] of jsonSchemaProperties(schema)) {
+  for (const [name, property] of Object.entries(schema.properties ?? {})) {
     const value = args[name]
-    if (value === undefined) continue
-    // `enum` is narrower than `type`, so a declared member is valid by definition. This
-    // has to precede the type branches: a `null` member satisfies none of them, and
-    // `coerceToolArguments` above has just recovered exactly that member.
-    if (jsonSchemaEnumMembers(property)?.includes(value)) continue
-    if (!hasType(property)) continue
+    if (value === undefined || !hasType(property)) continue
     const isValid =
       (property.type === 'string' && typeof value === 'string') ||
       (property.type === 'number' && typeof value === 'number') ||

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

@@ -7,12 +7,10 @@ import {
   buildSubBlockForToolParam,
   buildSubBlocksFromJsonSchema,
   buildToolParamShapes,
-  decodeJsonSchemaValue,
   decodeToolParams,
   decodeToolParamValue,
   encodeToolParamValue,
   expandSubBlockValueToParams,
-  getJsonSchemaValueShape,
   getSubBlockValueShape,
   getToolParamValueShape,
   subBlockTypeForValueType,
@@ -530,87 +528,43 @@ describe('buildJsonSchemaParamShapes', () => {
     expect(shapes.get('declaredStr')).toBe('string')
   })
 
-  it('infers an untyped enum from its members', () => {
+  it('reads an untyped enum from its members only to tell text from JSON', () => {
     const shapes = buildJsonSchemaParamShapes({
-      properties: {
-        nums: { enum: [1, 2] },
-        bools: { enum: [true, false] },
-        strs: { enum: ['x', 'y'] },
-        structured: { enum: [{ a: 1 }] },
-        mixed: { enum: [1, 'x'] },
-        // `every` is vacuously true on an empty enum — this must not read as numeric.
-        empty: { enum: [] },
-      },
+      properties: { primitive: { enum: ['x', 1, null] }, structured: { enum: [{ a: 1 }] } },
     })
 
-    expect(shapes.get('nums')).toBe('number')
-    expect(shapes.get('bools')).toBe('boolean')
-    expect(shapes.get('strs')).toBe('string')
+    // A structured member renders in a JSON editor; anything else renders as a dropdown,
+    // which stores text. The dropdown persists the member itself, so nothing has to
+    // reverse `String(member)` afterwards.
+    expect(shapes.get('primitive')).toBe('string')
     expect(shapes.get('structured')).toBe('json')
-    expect(shapes.get('mixed')).toBe('string')
-    expect(shapes.get('empty')).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)
+    const schema = { properties: { n: { type: 'integer', enum: [1, 2, 3] } } }
+    const [subBlock] = buildSubBlocksFromJsonSchema(schema, (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('inverts the dropdown encoding against the enum members', () => {
-    // Options are `String(member)`, and a shape cannot tell `'null'` the text from
-    // `null` the member — only the member list can.
-    const mixed = { enum: ['a', null, 2, true] }
-
-    expect(decodeJsonSchemaValue('null', mixed)).toBe(null)
-    expect(decodeJsonSchemaValue('2', mixed)).toBe(2)
-    expect(decodeJsonSchemaValue('true', mixed)).toBe(true)
-    expect(decodeJsonSchemaValue('a', mixed)).toBe('a')
+    expect(decodeToolParamValue('2', buildJsonSchemaParamShapes(schema).get('n')!)).toBe(2)
   })
 
   it('normalizes a property the server sent as something other than an object', () => {
-    // `properties: { foo: null }` is malformed but arrives over the wire, and the MCP
-    // executor reads its properties through here before any type guard runs.
+    // `properties: { foo: null }` is malformed but arrives over the wire.
     const shapes = buildJsonSchemaParamShapes({
       properties: { a: null, b: true, c: 'text', d: 42 },
     } as unknown as Parameters<typeof buildJsonSchemaParamShapes>[0])
 
     expect([...shapes.values()]).toEqual(['string', 'string', 'string', 'string'])
   })
 
-  it('leaves a value that is not an enum member to the shape codec', () => {
-    // A variable reference must survive, and an untouched field stays the '' sentinel.
-    expect(decodeJsonSchemaValue('<start.choice>', { enum: ['a', null] })).toBe('<start.choice>')
-    expect(decodeJsonSchemaValue('', { enum: ['a', null] })).toBe('')
-    expect(decodeJsonSchemaValue('false', { type: 'boolean' })).toBe(false)
-  })
-
   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)
-  })
-})
-
-describe('enum members that are not plain strings', () => {
-  it('keeps a nullable enum as text so a real null member survives the decode', () => {
-    const shape = getJsonSchemaValueShape({ enum: ['a', null] })
-
-    expect(shape).toBe('string')
-    // The dropdown persists the member itself, so `null` arrives already typed and the
-    // decode must not touch it.
-    expect(decodeToolParamValue(null, shape)).toBeNull()
-  })
+    const shapes = buildJsonSchemaParamShapes({
+      properties: { flag: { type: ['boolean', 'null'] }, plain: { type: 'boolean' } },
+    })
 
-  it('decodes a numeric enum member that is still stored as its stringified form', () => {
-    expect(
-      decodeToolParamValue('1', getJsonSchemaValueShape({ type: 'integer', enum: [1, 2] }))
-    ).toBe(1)
+    expect(decodeToolParamValue('false', shapes.get('flag')!)).toBe(false)
+    expect(decodeToolParamValue(true, shapes.get('plain')!)).toBe(true)
   })
 })

apps/sim/tools/param-shape.ts

@@ -409,67 +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.
  */
-export function getJsonSchemaValueShape(property: JsonSchemaProperty): ToolParamValueShape {
+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'
-}
+  // Read AFTER the declared type, not before: the dropdown an enum renders as stores
+  // `String(option)`, so `{ type: 'integer', enum: [1, 2] }` read as text would send
+  // `'1'` where the server expects `1`. With no declared type only a structured member
+  // is informative — it renders as free JSON text rather than a dropdown.
+  if (Array.isArray(property.enum)) {
+    return property.enum.some((member) => member !== null && typeof member === 'object')
+      ? 'json'
+      : 'string'
+  }
 
-/** The shape an enum's members share, for a property that declares no type. */
-function enumMemberShape(members: readonly unknown[]): ToolParamValueShape {
-  // `every` is vacuously true on an empty enum, which a third-party MCP schema may send.
-  if (members.length === 0) return 'string'
-  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'
 }
 
-/**
- * The enum member a dropdown's stored option id came from, or `undefined` for a value
- * that is not one of the members.
- *
- * Options are encoded as `String(member)` ({@link buildSubBlocksFromJsonSchema}), and
- * `String` is invertible only against the member list. A {@link ToolParamValueShape}
- * cannot recover a mixed enum: `['a', null]` shapes as `'string'`, so the selected
- * `null` reaches the server as the text `"null"`. Matching the stored text against the
- * members IS the exact inverse of the encoding, so it takes precedence over the shape.
- *
- * A value that matches nothing — a variable reference, an untouched field — is left for
- * the shape codec.
- */
-export function jsonSchemaEnumMember(value: unknown, property: JsonSchemaProperty): unknown {
-  if (typeof value !== 'string') return undefined
-  return jsonSchemaEnumMembers(property)?.find((member) => String(member) === value)
-}
-
-/** The members an untrusted property declares, or `undefined` when it declares none. */
-export function jsonSchemaEnumMembers(
-  property: JsonSchemaProperty
-): readonly unknown[] | undefined {
-  return Array.isArray(property.enum) ? property.enum : undefined
-}
-
-/**
- * Decode a value stored by the control {@link subBlockTypeForJsonSchema} picked for a
- * JSON Schema property — the enum-aware counterpart of {@link decodeToolParamValue}.
- */
-export function decodeJsonSchemaValue(value: unknown, property: JsonSchemaProperty): unknown {
-  const member = jsonSchemaEnumMember(value, property)
-  // Tested against `undefined`, never `??`: `null` is a legal member and must win.
-  if (member !== undefined) return member
-  return decodeToolParamValue(value, getJsonSchemaValueShape(property))
-}
-
 /** The value shape of every argument an MCP or custom tool's schema declares. */
 export function buildJsonSchemaParamShapes(
   schema: JsonSchemaObject | undefined
@@ -504,7 +463,7 @@ export interface JsonSchemaObject {
 }
 
 /** The declared properties of an untrusted schema, as `paramId -> property` pairs. */
-export function jsonSchemaProperties(
+function jsonSchemaProperties(
   schema: JsonSchemaObject | undefined
 ): Array<[string, JsonSchemaProperty]> {
   const { properties } = schema ?? {}