fix: preserve typed values when resolving workflow inputMapping references

The variable resolver stringifies all resolved references via
formatValueForBlock, which is correct for blocks that consume string
templates (agents, conditions, functions) but destroys type information
for workflow blocks whose inputMapping should pass arrays, objects,
numbers, and booleans to child workflows as-is.

When resolveTemplate encounters a pure reference (e.g. `<webhook.sender>`)
targeting a WORKFLOW or WORKFLOW_INPUT block, it now returns the resolved
value directly, bypassing string interpolation.

Additionally, buildUnifiedStartOutput was allowing raw workflowInput
strings to overwrite already-coerced structuredInput values. A
structuredKeys guard now prevents this.

Fixes #3105

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: waleedlatif1

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

@@ -215,5 +215,115 @@ describe('start-block utilities', () => {
 
       expect(output.customField).toBe('defaultValue')
     })
+
+    it.concurrent('preserves coerced types for unified start payload', () => {
+      const block = createBlock('start_trigger', 'start', {
+        subBlocks: {
+          inputFormat: {
+            value: [
+              { name: 'conversation_id', type: 'number' },
+              { name: 'sender', type: 'object' },
+              { name: 'is_active', type: 'boolean' },
+            ],
+          },
+        },
+      })
+
+      const resolution = {
+        blockId: 'start',
+        block,
+        path: StartBlockPath.UNIFIED,
+      } as const
+
+      const output = buildStartBlockOutput({
+        resolution,
+        workflowInput: {
+          conversation_id: '149',
+          sender: '{"id":10,"email":"user@example.com"}',
+          is_active: 'true',
+        },
+      })
+
+      expect(output.conversation_id).toBe(149)
+      expect(output.sender).toEqual({ id: 10, email: 'user@example.com' })
+      expect(output.is_active).toBe(true)
+    })
+
+    it.concurrent(
+      'prefers coerced inputFormat values over duplicated top-level workflowInput keys',
+      () => {
+        const block = createBlock('start_trigger', 'start', {
+          subBlocks: {
+            inputFormat: {
+              value: [
+                { name: 'conversation_id', type: 'number' },
+                { name: 'sender', type: 'object' },
+                { name: 'is_active', type: 'boolean' },
+              ],
+            },
+          },
+        })
+
+        const resolution = {
+          blockId: 'start',
+          block,
+          path: StartBlockPath.UNIFIED,
+        } as const
+
+        const output = buildStartBlockOutput({
+          resolution,
+          workflowInput: {
+            input: {
+              conversation_id: '149',
+              sender: '{"id":10,"email":"user@example.com"}',
+              is_active: 'false',
+            },
+            conversation_id: '150',
+            sender: '{"id":99,"email":"wrong@example.com"}',
+            is_active: 'true',
+            extra: 'keep-me',
+          },
+        })
+
+        expect(output.conversation_id).toBe(149)
+        expect(output.sender).toEqual({ id: 10, email: 'user@example.com' })
+        expect(output.is_active).toBe(false)
+        expect(output.extra).toBe('keep-me')
+      }
+    )
+  })
+
+  describe('EXTERNAL_TRIGGER path', () => {
+    it.concurrent('preserves coerced types for integration trigger payload', () => {
+      const block = createBlock('webhook', 'start', {
+        subBlocks: {
+          inputFormat: {
+            value: [
+              { name: 'count', type: 'number' },
+              { name: 'payload', type: 'object' },
+            ],
+          },
+        },
+      })
+
+      const resolution = {
+        blockId: 'start',
+        block,
+        path: StartBlockPath.EXTERNAL_TRIGGER,
+      } as const
+
+      const output = buildStartBlockOutput({
+        resolution,
+        workflowInput: {
+          count: '5',
+          payload: '{"event":"push"}',
+          extra: 'untouched',
+        },
+      })
+
+      expect(output.count).toBe(5)
+      expect(output.payload).toEqual({ event: 'push' })
+      expect(output.extra).toBe('untouched')
+    })
   })
 })

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

@@ -262,6 +262,7 @@ function buildUnifiedStartOutput(
   hasStructured: boolean
 ): NormalizedBlockOutput {
   const output: NormalizedBlockOutput = {}
+  const structuredKeys = hasStructured ? new Set(Object.keys(structuredInput)) : null
 
   if (hasStructured) {
     for (const [key, value] of Object.entries(structuredInput)) {
@@ -272,6 +273,9 @@ function buildUnifiedStartOutput(
   if (isPlainObject(workflowInput)) {
     for (const [key, value] of Object.entries(workflowInput)) {
       if (key === 'onUploadError') continue
+      // Skip keys already set by schema-coerced structuredInput to
+      // prevent raw workflowInput strings from overwriting typed values.
+      if (structuredKeys?.has(key)) continue
       // Runtime values override defaults (except undefined/null which mean "not provided")
       if (value !== undefined && value !== null) {
         output[key] = value
@@ -384,6 +388,7 @@ function buildIntegrationTriggerOutput(
   hasStructured: boolean
 ): NormalizedBlockOutput {
   const output: NormalizedBlockOutput = {}
+  const structuredKeys = hasStructured ? new Set(Object.keys(structuredInput)) : null
 
   if (hasStructured) {
     for (const [key, value] of Object.entries(structuredInput)) {
@@ -393,6 +398,7 @@ function buildIntegrationTriggerOutput(
 
   if (isPlainObject(workflowInput)) {
     for (const [key, value] of Object.entries(workflowInput)) {
+      if (structuredKeys?.has(key)) continue
       if (value !== undefined && value !== null) {
         output[key] = value
       } else if (!Object.hasOwn(output, key)) {

apps/sim/executor/variables/resolver.test.ts

@@ -0,0 +1,208 @@
+import { describe, expect, it } from 'vitest'
+import { BlockType } from '@/executor/constants'
+import { ExecutionState } from '@/executor/execution/state'
+import type { ExecutionContext } from '@/executor/types'
+import { VariableResolver } from '@/executor/variables/resolver'
+import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
+
+function createSerializedBlock(opts: { id: string; name: string; type: string }): SerializedBlock {
+  return {
+    id: opts.id,
+    position: { x: 0, y: 0 },
+    config: { tool: opts.type, params: {} },
+    inputs: {},
+    outputs: {},
+    metadata: { id: opts.type, name: opts.name },
+    enabled: true,
+  }
+}
+
+describe('VariableResolver', () => {
+  it.concurrent('preserves typed values for workflow_input pure references', () => {
+    const workflow: SerializedWorkflow = {
+      version: 'test',
+      blocks: [createSerializedBlock({ id: 'webhook', name: 'webhook', type: BlockType.TRIGGER })],
+      connections: [],
+      loops: {},
+      parallels: {},
+    }
+
+    const state = new ExecutionState()
+    state.setBlockOutput('webhook', {
+      conversation_id: 149,
+      sender: { id: 10, email: 'user@example.com' },
+      is_active: true,
+    })
+
+    const resolver = new VariableResolver(workflow, {}, state)
+    const ctx = { blockStates: new Map() } as unknown as ExecutionContext
+
+    const workflowInputBlock = createSerializedBlock({
+      id: 'wf',
+      name: 'Workflow',
+      type: BlockType.WORKFLOW_INPUT,
+    })
+
+    const resolved = resolver.resolveInputs(
+      ctx,
+      'wf',
+      {
+        inputMapping: {
+          conversation_id: '<webhook.conversation_id>',
+          sender: '<webhook.sender>',
+          is_active: '<webhook.is_active>',
+        },
+      },
+      workflowInputBlock
+    )
+
+    expect(resolved.inputMapping.conversation_id).toBe(149)
+    expect(resolved.inputMapping.sender).toEqual({ id: 10, email: 'user@example.com' })
+    expect(resolved.inputMapping.is_active).toBe(true)
+  })
+
+  it.concurrent('formats pure references as strings for non-workflow blocks', () => {
+    const workflow: SerializedWorkflow = {
+      version: 'test',
+      blocks: [createSerializedBlock({ id: 'webhook', name: 'webhook', type: BlockType.TRIGGER })],
+      connections: [],
+      loops: {},
+      parallels: {},
+    }
+
+    const state = new ExecutionState()
+    state.setBlockOutput('webhook', { conversation_id: 149 })
+
+    const resolver = new VariableResolver(workflow, {}, state)
+    const ctx = { blockStates: new Map() } as unknown as ExecutionContext
+
+    const apiBlock = createSerializedBlock({
+      id: 'api',
+      name: 'API',
+      type: BlockType.API,
+    })
+
+    const resolved = resolver.resolveInputs(
+      ctx,
+      'api',
+      { conversation_id: '<webhook.conversation_id>' },
+      apiBlock
+    )
+
+    expect(resolved.conversation_id).toBe('149')
+  })
+
+  it.concurrent('preserves nulls and arrays for workflow blocks with pure references', () => {
+    const workflow: SerializedWorkflow = {
+      version: 'test',
+      blocks: [createSerializedBlock({ id: 'webhook', name: 'webhook', type: BlockType.TRIGGER })],
+      connections: [],
+      loops: {},
+      parallels: {},
+    }
+
+    const state = new ExecutionState()
+    state.setBlockOutput('webhook', {
+      items: [1, { a: 2 }, [3]],
+      nothing: null,
+    })
+
+    const resolver = new VariableResolver(workflow, {}, state)
+    const ctx = { blockStates: new Map() } as unknown as ExecutionContext
+
+    const workflowBlock = createSerializedBlock({
+      id: 'wf',
+      name: 'Workflow',
+      type: BlockType.WORKFLOW,
+    })
+
+    const resolved = resolver.resolveInputs(
+      ctx,
+      'wf',
+      {
+        inputMapping: {
+          items: '  <webhook.items>  ',
+          nothing: '<webhook.nothing>',
+        },
+      },
+      workflowBlock
+    )
+
+    expect(resolved.inputMapping.items).toEqual([1, { a: 2 }, [3]])
+    expect(resolved.inputMapping.nothing).toBeNull()
+  })
+
+  it.concurrent('still stringifies when a reference is embedded in text', () => {
+    const workflow: SerializedWorkflow = {
+      version: 'test',
+      blocks: [createSerializedBlock({ id: 'webhook', name: 'webhook', type: BlockType.TRIGGER })],
+      connections: [],
+      loops: {},
+      parallels: {},
+    }
+
+    const state = new ExecutionState()
+    state.setBlockOutput('webhook', { conversation_id: 149 })
+
+    const resolver = new VariableResolver(workflow, {}, state)
+    const ctx = { blockStates: new Map() } as unknown as ExecutionContext
+
+    const workflowInputBlock = createSerializedBlock({
+      id: 'wf',
+      name: 'Workflow',
+      type: BlockType.WORKFLOW_INPUT,
+    })
+
+    const resolved = resolver.resolveInputs(
+      ctx,
+      'wf',
+      {
+        label: 'id=<webhook.conversation_id>',
+      },
+      workflowInputBlock
+    )
+
+    expect(resolved.label).toBe('id=149')
+  })
+
+  it.concurrent('returns null for RESOLVED_EMPTY references in workflow blocks', () => {
+    const workflow: SerializedWorkflow = {
+      version: 'test',
+      blocks: [
+        createSerializedBlock({ id: 'webhook', name: 'webhook', type: BlockType.TRIGGER }),
+        createSerializedBlock({ id: 'agent', name: 'Agent', type: BlockType.AGENT }),
+      ],
+      connections: [],
+      loops: {},
+      parallels: {},
+    }
+
+    const state = new ExecutionState()
+    // webhook has output, but agent has none (never executed on this path)
+    state.setBlockOutput('webhook', { conversation_id: 149 })
+
+    const resolver = new VariableResolver(workflow, {}, state)
+    const ctx = { blockStates: new Map() } as unknown as ExecutionContext
+
+    const workflowBlock = createSerializedBlock({
+      id: 'wf',
+      name: 'Workflow',
+      type: BlockType.WORKFLOW,
+    })
+
+    const resolved = resolver.resolveInputs(
+      ctx,
+      'wf',
+      {
+        inputMapping: {
+          from_webhook: '<webhook.conversation_id>',
+          from_agent: '<Agent.response>',
+        },
+      },
+      workflowBlock
+    )
+
+    expect(resolved.inputMapping.from_webhook).toBe(149)
+    expect(resolved.inputMapping.from_agent).toBeNull()
+  })
+})

apps/sim/executor/variables/resolver.ts

@@ -155,17 +155,36 @@ export class VariableResolver {
     template: string,
     loopScope?: LoopScope,
     block?: SerializedBlock
-  ): string {
+  ): any {
     const resolutionContext: ResolutionContext = {
       executionContext: ctx,
       executionState: this.state,
       currentNodeId,
       loopScope,
     }
 
-    let replacementError: Error | null = null
-
     const blockType = block?.metadata?.id
+
+    // For workflow blocks with pure references (e.g. "<webhook.sender>"),
+    // return the resolved value directly to preserve its native type.
+    // Other blocks need string interpolation, but workflow inputMapping
+    // should pass arrays, objects, numbers, and booleans as-is.
+    const trimmed = template.trim()
+    const isPureReference = /^<[^<>]+>$/.test(trimmed)
+    const isWorkflowBlock =
+      blockType === BlockType.WORKFLOW || blockType === BlockType.WORKFLOW_INPUT
+    if (isWorkflowBlock && isPureReference) {
+      const resolved = this.resolveReference(trimmed, resolutionContext)
+      if (resolved === RESOLVED_EMPTY) {
+        return null
+      }
+      if (resolved !== undefined) {
+        return resolved
+      }
+      return template
+    }
+
+    let replacementError: Error | null = null
     const language =
       blockType === BlockType.FUNCTION
         ? ((block?.config?.params as Record<string, unknown> | undefined)?.language as