improvment(executor): reserved keyword errors

Author: icecrasher321

apps/sim/executor/types.ts

@@ -213,6 +213,15 @@ export interface NormalizedBlockOutput {
   _pauseMetadata?: PauseMetadata
 }
 
+export const EXECUTION_CONTROL_OUTPUT_FIELD_NAMES = [
+  'error',
+  'selectedOption',
+  'selectedRoute',
+  '_pauseMetadata',
+] as const
+
+export type ExecutionControlOutputFieldName = (typeof EXECUTION_CONTROL_OUTPUT_FIELD_NAMES)[number]
+
 export interface BlockLog {
   blockId: string
   blockName?: string

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

@@ -119,6 +119,102 @@ describe('start-block utilities', () => {
     expect(output.files).toEqual(files)
   })
 
+  it.concurrent('rejects inputFormat fields that collide with executor routing keys', () => {
+    const block = createBlock('start_trigger', 'start', {
+      subBlocks: {
+        inputFormat: {
+          value: [
+            { name: 'error', type: 'string' },
+            { name: 'error', type: 'string' },
+            { name: ' selectedOption ', type: 'string' },
+            { name: 'selectedRoute', type: 'string' },
+            { name: '_pauseMetadata', type: 'object' },
+          ],
+        },
+      },
+    })
+
+    const resolution = {
+      blockId: 'start',
+      block,
+      path: StartBlockPath.UNIFIED,
+    } as const
+
+    expect(() =>
+      buildStartBlockOutput({
+        resolution,
+        workflowInput: { error: false, selectedRoute: 'source' },
+      })
+    ).toThrow(
+      'Start block "block-start_trigger" cannot use reserved input format field name(s): error, selectedOption, selectedRoute, _pauseMetadata'
+    )
+  })
+
+  it.concurrent(
+    'rejects reserved top-level runtime input keys copied to unified Start output',
+    () => {
+      const block = createBlock('start_trigger', 'start')
+      const resolution = {
+        blockId: 'start',
+        block,
+        path: StartBlockPath.UNIFIED,
+      } as const
+
+      expect(() =>
+        buildStartBlockOutput({
+          resolution,
+          workflowInput: { error: 'false', payload: 'value' },
+        })
+      ).toThrow(
+        'Start block "block-start_trigger" cannot use reserved runtime input field name(s): error'
+      )
+    }
+  )
+
+  it.concurrent('rejects reserved nested API input keys copied to trigger output', () => {
+    const block = createBlock('api_trigger', 'api')
+    const resolution = {
+      blockId: 'api',
+      block,
+      path: StartBlockPath.SPLIT_API,
+    } as const
+
+    expect(() =>
+      buildStartBlockOutput({
+        resolution,
+        workflowInput: { input: { selectedRoute: 'route-1', payload: 'value' } },
+      })
+    ).toThrow(
+      'Start block "block-api_trigger" cannot use reserved runtime input field name(s): selectedRoute'
+    )
+  })
+
+  it.concurrent('ignores malformed non-string inputFormat field names', () => {
+    const block = createBlock('start_trigger', 'start', {
+      subBlocks: {
+        inputFormat: {
+          value: [
+            { name: 123, type: 'string', value: 'ignored' },
+            { name: 'customField', type: 'string' },
+          ],
+        },
+      },
+    })
+    const resolution = {
+      blockId: 'start',
+      block,
+      path: StartBlockPath.UNIFIED,
+    } as const
+
+    const output = buildStartBlockOutput({
+      resolution,
+      workflowInput: { customField: 'value' },
+    })
+
+    expect(output.customField).toBe('value')
+    expect(output[123]).toBeUndefined()
+  })
+
   describe('inputFormat default values', () => {
     it.concurrent('uses default value when runtime does not provide the field', () => {
       const block = createBlock('start_trigger', 'start', {
@@ -294,6 +390,24 @@ describe('start-block utilities', () => {
   })
 
   describe('EXTERNAL_TRIGGER path', () => {
+    it.concurrent('rejects reserved runtime input keys copied to external trigger output', () => {
+      const block = createBlock('webhook', 'start')
+      const resolution = {
+        blockId: 'start',
+        block,
+        path: StartBlockPath.EXTERNAL_TRIGGER,
+      } as const
+
+      expect(() =>
+        buildStartBlockOutput({
+          resolution,
+          workflowInput: { _pauseMetadata: { contextId: 'fake-pause' }, payload: 'value' },
+        })
+      ).toThrow(
+        'Start block "block-webhook" cannot use reserved runtime input field name(s): _pauseMetadata'
+      )
+    })
+
     it.concurrent('preserves coerced types for integration trigger payload', () => {
       const block = createBlock('webhook', 'start', {
         subBlocks: {

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

@@ -6,12 +6,20 @@ import {
   StartBlockPath,
 } from '@/lib/workflows/triggers/triggers'
 import type { InputFormatField } from '@/lib/workflows/types'
-import type { NormalizedBlockOutput, UserFile } from '@/executor/types'
+import {
+  EXECUTION_CONTROL_OUTPUT_FIELD_NAMES,
+  type NormalizedBlockOutput,
+  type UserFile,
+} from '@/executor/types'
 import type { SerializedBlock } from '@/serializer/types'
 import { safeAssign } from '@/tools/safe-assign'
 
 type ExecutionKind = 'chat' | 'manual' | 'api' | 'external'
 
+const EXECUTION_CONTROL_OUTPUT_FIELD_NAME_SET = new Set<string>(
+  EXECUTION_CONTROL_OUTPUT_FIELD_NAMES
+)
+
 export interface ExecutorStartResolution {
   blockId: string
   block: SerializedBlock
@@ -133,6 +141,66 @@ function extractInputFormat(block: SerializedBlock): InputFormatField[] {
     .map((field) => field)
 }
 
+function readInputFormatFieldName(field: InputFormatField): string | undefined {
+  return typeof field.name === 'string' ? field.name.trim() : undefined
+}
+
+function collectExecutionControlFieldNames(fieldNames: Iterable<string | undefined>): string[] {
+  const reservedFieldNames: string[] = []
+
+  for (const fieldName of fieldNames) {
+    if (!fieldName || !EXECUTION_CONTROL_OUTPUT_FIELD_NAME_SET.has(fieldName)) {
+      continue
+    }
+
+    if (!reservedFieldNames.includes(fieldName)) {
+      reservedFieldNames.push(fieldName)
+    }
+  }
+
+  return reservedFieldNames
+}
+
+function throwReservedStartOutputFieldsError(
+  block: SerializedBlock,
+  reservedFieldNames: string[],
+  source: 'input format' | 'runtime input'
+): never {
+  const blockName = block.metadata?.name ?? block.id
+
+  throw new Error(
+    `Start block "${blockName}" cannot use reserved ${source} field name(s): ${reservedFieldNames.join(', ')}. These names control workflow execution and cannot be used as Start outputs. Rename these fields before running the workflow. Reserved names are: ${EXECUTION_CONTROL_OUTPUT_FIELD_NAMES.join(', ')}.`
+  )
+}
+
+function assertNoReservedInputFormatFields(
+  inputFormat: InputFormatField[],
+  block: SerializedBlock
+): void {
+  const reservedFieldNames = collectExecutionControlFieldNames(
+    inputFormat.map(readInputFormatFieldName)
+  )
+
+  if (reservedFieldNames.length === 0) {
+    return
+  }
+
+  throwReservedStartOutputFieldsError(block, reservedFieldNames, 'input format')
+}
+
+function assertNoReservedStartOutputFields(
+  output: NormalizedBlockOutput,
+  block: SerializedBlock
+): void {
+  const reservedFieldNames = collectExecutionControlFieldNames(Object.keys(output))
+
+  if (reservedFieldNames.length === 0) {
+    return
+  }
+
+  throwReservedStartOutputFieldsError(block, reservedFieldNames, 'runtime input')
+}
+
 export function coerceValue(type: string | null | undefined, value: unknown): unknown {
   if (value === undefined || value === null) {
     return value
@@ -190,7 +258,7 @@ function deriveInputFromFormat(
   }
 
   for (const field of inputFormat) {
-    const fieldName = field.name?.trim()
+    const fieldName = readInputFormatFieldName(field)
     if (!fieldName) continue
 
     let fieldValue: unknown
@@ -436,35 +504,48 @@ export interface StartBlockOutputOptions {
 export function buildStartBlockOutput(options: StartBlockOutputOptions): NormalizedBlockOutput {
   const { resolution, workflowInput } = options
   const inputFormat = extractInputFormat(resolution.block)
+  assertNoReservedInputFormatFields(inputFormat, resolution.block)
   const { finalInput, structuredInput, hasStructured } = deriveInputFromFormat(
     inputFormat,
     workflowInput
   )
 
+  let output: NormalizedBlockOutput
+
   switch (resolution.path) {
     case StartBlockPath.UNIFIED:
-      return buildUnifiedStartOutput(workflowInput, structuredInput, hasStructured)
+      output = buildUnifiedStartOutput(workflowInput, structuredInput, hasStructured)
+      break
 
     case StartBlockPath.SPLIT_API:
     case StartBlockPath.SPLIT_INPUT:
-      return buildApiOrInputOutput(finalInput, workflowInput)
+      output = buildApiOrInputOutput(finalInput, workflowInput)
+      break
 
     case StartBlockPath.SPLIT_CHAT:
-      return buildChatOutput(workflowInput)
+      output = buildChatOutput(workflowInput)
+      break
 
     case StartBlockPath.SPLIT_MANUAL:
-      return buildManualTriggerOutput(finalInput, workflowInput)
+      output = buildManualTriggerOutput(finalInput, workflowInput)
+      break
 
     case StartBlockPath.EXTERNAL_TRIGGER:
-      return buildIntegrationTriggerOutput(workflowInput, structuredInput, hasStructured)
+      output = buildIntegrationTriggerOutput(workflowInput, structuredInput, hasStructured)
+      break
 
     case StartBlockPath.LEGACY_STARTER:
-      return buildLegacyStarterOutput(
+      output = buildLegacyStarterOutput(
         finalInput,
         workflowInput,
         getLegacyStarterMode({ subBlocks: extractSubBlocks(resolution.block) })
       )
+      break
+
     default:
-      return buildManualTriggerOutput(finalInput, workflowInput)
+      output = buildManualTriggerOutput(finalInput, workflowInput)
   }
+
+  assertNoReservedStartOutputFields(output, resolution.block)
+  return output
 }