fix(workflows): accept legacy input field types instead of rejecting them

apps/sim/executor/utils/start-block.test.ts

@@ -454,7 +454,7 @@ describe('start-block utilities', () => {
 
       expect(output.count).toBe(5)
       expect(output.payload).toEqual({ event: 'push' })
-      expect(output.meta).toEqual({ source: 'api' })
+      expect(output.meta).toBe('{"source":"api"}')
       expect(output.extra).toBe('untouched')
     })
   })

apps/sim/executor/utils/start-block.ts

@@ -7,7 +7,6 @@ import {
   isInternalFileUrl,
   parseInternalFileUrl,
 } from '@/lib/uploads/utils/file'
-import { canonicalInputFormatFieldType } from '@/lib/workflows/input-format-schema'
 import {
   classifyStartBlockType,
   resolveStartCandidates,
@@ -246,7 +245,7 @@ export function coerceValue(type: string | null | undefined, value: unknown): un
     return value
   }
 
-  switch (type ? (canonicalInputFormatFieldType(type) ?? type) : type) {
+  switch (type) {
     case 'string':
       return typeof value === 'string' ? value : String(value)
     case 'number': {

apps/sim/lib/workflows/editing/validation.test.ts

@@ -345,34 +345,27 @@ describe('validateInputsForBlock', () => {
     ).toBe(false)
   })
 
-  describe('input-format', () => {
-    const config = { id: 'inputFormat', type: 'input-format' as const }
-    const validate = (value: unknown) =>
-      validateValueForSubBlockType(config, value, 'inputFormat', 'start_trigger', 'start-1')
-
-    it('stores type aliases as their canonical type and keeps untyped rows', () => {
-      expect(
-        validate([
-          { name: 'payload', type: 'json' },
-          { name: 'documents', type: 'files' },
-          { name: 'message' },
-        ])
-      ).toEqual({
-        valid: true,
-        value: [
-          { name: 'payload', type: 'object' },
-          { name: 'documents', type: 'file[]' },
-          { name: 'message' },
-        ],
-      })
-    })
-
-    it('rejects a type no workflow input can declare, listing the allowed types', () => {
-      const result = validate([{ name: 'count', type: 'integer' }])
-      expect(result.valid).toBe(false)
-      expect(result.error?.error).toBe(
-        'Invalid type "integer" for inputFormat[0] - use one of: string, number, boolean, object, array, file[]'
+  it('stores input-format rows with legacy or aliased types unchanged', () => {
+    const rows = [
+      { name: 'payload', type: 'json' },
+      { name: 'title', type: 'short-input' },
+      { name: 'message' },
+    ]
+    expect(
+      validateValueForSubBlockType(
+        { id: 'inputFormat', type: 'input-format' },
+        rows,
+        'inputFormat',
+        'start_trigger',
+        'start-1'
       )
+    ).toEqual({
+      valid: true,
+      value: [
+        { name: 'payload', type: 'json' },
+        { name: 'title', type: 'short-input' },
+        { name: 'message' },
+      ],
     })
   })
 

apps/sim/lib/workflows/editing/validation.ts

@@ -24,10 +24,6 @@ import {
   type SelectorReference,
   validateSelectorIds,
 } from '@/lib/workflows/editing/selector-validator'
-import {
-  canonicalInputFormatFieldType,
-  INPUT_FORMAT_FIELD_TYPES,
-} from '@/lib/workflows/input-format-schema'
 import { containsReference } from '@/lib/workflows/sanitization/references'
 import { getSkillById } from '@/lib/workflows/skills/operations'
 import {
@@ -643,44 +639,7 @@ export function validateValueForSubBlockType(
       return { valid: true, value }
     }
 
-    case 'input-format': {
-      if (!Array.isArray(value)) {
-        return {
-          valid: false,
-          error: {
-            blockId,
-            blockType,
-            field: fieldName,
-            value,
-            error: `Invalid ${type} value for field "${fieldName}" - expected an array`,
-          },
-        }
-      }
-      const rows: unknown[] = []
-      for (const [index, row] of value.entries()) {
-        if (!isPlainRecord(row) || row.type === undefined) {
-          rows.push(row)
-          continue
-        }
-        const fieldType =
-          typeof row.type === 'string' ? canonicalInputFormatFieldType(row.type) : null
-        if (!fieldType) {
-          return {
-            valid: false,
-            error: {
-              blockId,
-              blockType,
-              field: fieldName,
-              value,
-              error: `Invalid type ${JSON.stringify(row.type)} for ${fieldName}[${index}] - use one of: ${INPUT_FORMAT_FIELD_TYPES.join(', ')}`,
-            },
-          }
-        }
-        rows.push(fieldType === row.type ? row : { ...row, type: fieldType })
-      }
-      return { valid: true, value: rows }
-    }
-
+    case 'input-format':
     case 'table': {
       // Should be an array
       if (!Array.isArray(value)) {

apps/sim/lib/workflows/input-format-schema.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod'
 
-/** The input field types the editor offers and workflow runs accept. */
-export const INPUT_FORMAT_FIELD_TYPES = [
+/** The input field types the editor offers. */
+const INPUT_FORMAT_FIELD_TYPES = [
   'string',
   'number',
   'boolean',
@@ -12,14 +12,9 @@ export const INPUT_FORMAT_FIELD_TYPES = [
 
 export type InputFormatFieldType = (typeof INPUT_FORMAT_FIELD_TYPES)[number]
 
-/**
- * Every spelling a stored field's `type` may use, mapped to its canonical type:
- * `json` is the name blocks use for object params and outputs, `files` the
- * legacy MCP alias.
- */
+/** Every canonical type by name, plus `files`, the legacy MCP alias of `file[]`. */
 const INPUT_FORMAT_FIELD_TYPES_BY_NAME = new Map<string, InputFormatFieldType>([
   ...INPUT_FORMAT_FIELD_TYPES.map((type) => [type, type] as const),
-  ['json', 'object'],
   ['files', 'file[]'],
 ])
 

apps/sim/lib/workflows/input-schema.test.ts

@@ -108,25 +108,22 @@ describe('workflow input schemas', () => {
     expect(z.object(generateWorkflowInputShape(fields)).parse(input)).toEqual(input)
   })
 
-  it('accepts the json and files aliases as their canonical types', () => {
-    const shape = z.object(
-      generateWorkflowInputShape([
-        { name: 'payload', type: 'json' },
-        { name: 'documents', type: 'files' },
-      ])
-    )
-    expect(shape.safeParse({ payload: { a: 1 }, documents: [file] }).success).toBe(true)
-    expect(shape.safeParse({ payload: 'text', documents: [file] }).success).toBe(false)
+  it('accepts the files alias as file[]', () => {
+    const shape = z.object(generateWorkflowInputShape([{ name: 'documents', type: 'files' }]))
+    expect(shape.safeParse({ documents: [file] }).success).toBe(true)
+    expect(shape.safeParse({ documents: 'text' }).success).toBe(false)
   })
 
-  it('rejects unsupported type names as a validation failure naming the field', () => {
-    expect(() => generateToolInputSchema([{ name: 'count', type: 'unsupported' }])).toThrow(
-      expect.objectContaining({
-        name: 'OrchestrationError',
-        code: 'validation',
-        message:
-          'Workflow input "count" has unsupported type "unsupported". Use one of: string, number, boolean, object, array, file[].',
+  it.each(['short-input', 'json'])(
+    'accepts any value for the legacy type %s and advertises no type for it',
+    (type) => {
+      const fields = [{ name: 'title', type }]
+      expect(generateToolInputSchema(fields).properties).toEqual({
+        title: { description: 'title' },
       })
-    )
-  })
+      const shape = z.object(generateWorkflowInputShape(fields))
+      expect(shape.safeParse({ title: 'Quarterly report' }).success).toBe(true)
+      expect(shape.safeParse({ title: { text: 'Quarterly report' } }).success).toBe(true)
+    }
+  )
 })

apps/sim/lib/workflows/input-schema.ts

@@ -3,13 +3,16 @@ import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { workflowFileInputSchema } from '@/lib/workflows/input-file-schema'
 import {
   canonicalInputFormatFieldType,
-  INPUT_FORMAT_FIELD_TYPES,
   type InputFormatFieldType,
 } from '@/lib/workflows/input-format-schema'
 import type { InputFormatField } from '@/lib/workflows/types'
 import { isSafeKey } from '@/tools/safe-assign'
 
-function fieldTypeToSchema(type: InputFormatFieldType): z.ZodType {
+/**
+ * A stored type outside the editor's list (legacy widget names such as `short-input`) accepts any
+ * value, as the executor passes it through unchanged.
+ */
+function fieldTypeToSchema(type: InputFormatFieldType | null): z.ZodType {
   switch (type) {
     case 'string':
       return z.string()
@@ -23,15 +26,16 @@ function fieldTypeToSchema(type: InputFormatFieldType): z.ZodType {
       return z.array(z.unknown())
     case 'file[]':
       return z.array(workflowFileInputSchema)
+    case null:
+      return z.unknown()
   }
 }
 
 /**
  * Shared by workflow run validation and MCP discovery so the advertised input
  * types match execution. The executor supplies configured defaults at run time.
  *
- * @throws OrchestrationError `validation` when a field name is reserved or its
- * type is not one a workflow input can declare.
+ * @throws OrchestrationError `validation` when a field name is reserved.
  */
 export function generateWorkflowInputShape(inputFormat: InputFormatField[]): z.ZodRawShape {
   const shape: Record<string, z.ZodType> = {}
@@ -46,12 +50,6 @@ export function generateWorkflowInputShape(inputFormat: InputFormatField[]): z.Z
       )
     }
     const type = canonicalInputFormatFieldType(field.type)
-    if (!type) {
-      throw new OrchestrationError(
-        'validation',
-        `Workflow input "${name}" has unsupported type "${field.type}". Use one of: ${INPUT_FORMAT_FIELD_TYPES.join(', ')}.`
-      )
-    }
 
     const schema = fieldTypeToSchema(type).describe(
       field.description?.trim() ||

apps/sim/lib/workflows/triggers/run-options.test.ts

@@ -115,16 +115,15 @@ describe('file inputs through workflow run options', () => {
   })
 })
 
-describe('mock payloads for aliased field types', () => {
-  it('samples a json field as an object the run validation accepts', () => {
+describe('mock payloads for legacy field types', () => {
+  it('samples a json field with a value the run validation accepts', () => {
     const [option] = resolveTriggerRunOptions({
       start: {
         type: 'start_trigger',
         name: 'Start',
         subBlocks: { inputFormat: { value: [{ name: 'payload', type: 'json' }] } },
       },
     })
-    expect(option.mockPayload).toEqual({ payload: {} })
     expect(validateTriggerInput(option, option.mockPayload)).toEqual({ ok: true })
   })
 })