improvement(func-exec): normalize inputs to match schema (#4473)

icecrasher321 · waleedlatif1 · commit eb6bdf0da016 · 2026-05-06T18:28:39.000-07:00
diff --git a/apps/sim/executor/execution/block-executor.ts b/apps/sim/executor/execution/block-executor.ts
@@ -1,6 +1,7 @@
 import { createLogger, type Logger } from '@sim/logger'
 import { toError } from '@sim/utils/errors'
 import { redactApiKeys } from '@/lib/core/security/redaction'
+import { normalizeStringArray } from '@/lib/core/utils/arrays'
 import { getBaseUrl } from '@/lib/core/utils/urls'
 import {
   containsUserFileWithMetadata,
@@ -164,7 +165,7 @@ export class BlockExecutor {
             block,
             streamingExec,
             resolvedInputs,
-            ctx.selectedOutputs ?? []
+            normalizeStringArray(ctx.selectedOutputs)
           )
         }
 
diff --git a/apps/sim/executor/execution/executor.ts b/apps/sim/executor/execution/executor.ts
@@ -1,4 +1,6 @@
 import { createLogger, type Logger } from '@sim/logger'
+import { normalizeStringArray } from '@/lib/core/utils/arrays'
+import { normalizeStringRecord, normalizeWorkflowVariables } from '@/lib/core/utils/records'
 import { StartBlockPath } from '@/lib/workflows/triggers/triggers'
 import type { DAG } from '@/executor/dag/builder'
 import { DAGBuilder } from '@/executor/dag/builder'
@@ -56,9 +58,9 @@ export class DAGExecutor {
 
   constructor(options: DAGExecutorOptions) {
     this.workflow = options.workflow
-    this.environmentVariables = options.envVarValues ?? {}
+    this.environmentVariables = normalizeStringRecord(options.envVarValues)
     this.workflowInput = options.workflowInput ?? {}
-    this.workflowVariables = options.workflowVariables ?? {}
+    this.workflowVariables = normalizeWorkflowVariables(options.workflowVariables)
     this.contextExtensions = options.contextExtensions ?? {}
     this.dagBuilder = new DAGBuilder()
     this.execLogger = logger.withMetadata({
@@ -325,7 +327,7 @@ export class DAGExecutor {
         : new Set(),
       workflow: this.workflow,
       stream: this.contextExtensions.stream ?? false,
-      selectedOutputs: this.contextExtensions.selectedOutputs ?? [],
+      selectedOutputs: normalizeStringArray(this.contextExtensions.selectedOutputs),
       edges: this.contextExtensions.edges ?? [],
       onStream: this.contextExtensions.onStream,
       onBlockStart: this.contextExtensions.onBlockStart,
diff --git a/apps/sim/executor/execution/snapshot-serializer.ts b/apps/sim/executor/execution/snapshot-serializer.ts
@@ -119,8 +119,8 @@ export function serializePauseSnapshot(
     executionMetadata,
     context.workflow,
     {},
-    context.workflowVariables ?? {},
-    context.selectedOutputs ?? [],
+    context.workflowVariables,
+    context.selectedOutputs,
     state
   )
 
diff --git a/apps/sim/executor/execution/snapshot.test.ts b/apps/sim/executor/execution/snapshot.test.ts
@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest'
+import { ExecutionSnapshot } from '@/executor/execution/snapshot'
+import type { ExecutionMetadata } from '@/executor/execution/types'
+
+const metadata: ExecutionMetadata = {
+  requestId: 'request-1',
+  executionId: 'execution-1',
+  workflowId: 'workflow-1',
+  workspaceId: 'workspace-1',
+  userId: 'user-1',
+  triggerType: 'manual',
+  startTime: '2026-05-06T00:00:00.000Z',
+}
+
+describe('ExecutionSnapshot', () => {
+  it('normalizes untyped persisted execution state at construction', () => {
+    const variable = { id: 'var-1', name: 'brand', type: 'plain', value: 'myfitness' }
+
+    const snapshot = new ExecutionSnapshot(
+      metadata,
+      { blocks: [] },
+      {},
+      [variable],
+      ['agent.content', 123, 'function.result']
+    )
+
+    expect(snapshot.workflowVariables).toEqual({ 'var-1': variable })
+    expect(snapshot.selectedOutputs).toEqual(['agent.content', 'function.result'])
+  })
+})
diff --git a/apps/sim/executor/execution/snapshot.ts b/apps/sim/executor/execution/snapshot.ts
@@ -1,14 +1,30 @@
+import { normalizeStringArray } from '@/lib/core/utils/arrays'
+import { normalizeWorkflowVariables } from '@/lib/core/utils/records'
 import type { ExecutionMetadata, SerializableExecutionState } from '@/executor/execution/types'
 
 export class ExecutionSnapshot {
+  public readonly metadata: ExecutionMetadata
+  public readonly workflow: any
+  public readonly input: any
+  public readonly workflowVariables: Record<string, any>
+  public readonly selectedOutputs: string[]
+  public readonly state?: SerializableExecutionState
+
   constructor(
-    public readonly metadata: ExecutionMetadata,
-    public readonly workflow: any,
-    public readonly input: any,
-    public readonly workflowVariables: Record<string, any>,
-    public readonly selectedOutputs: string[] = [],
-    public readonly state?: SerializableExecutionState
-  ) {}
+    metadata: ExecutionMetadata,
+    workflow: any,
+    input: any,
+    workflowVariables: unknown,
+    selectedOutputs: unknown = [],
+    state?: SerializableExecutionState
+  ) {
+    this.metadata = metadata
+    this.workflow = workflow
+    this.input = input
+    this.workflowVariables = normalizeWorkflowVariables(workflowVariables)
+    this.selectedOutputs = normalizeStringArray(selectedOutputs)
+    this.state = state
+  }
 
   toJSON(): string {
     return JSON.stringify({
diff --git a/apps/sim/executor/handlers/agent/agent-handler.ts b/apps/sim/executor/handlers/agent/agent-handler.ts
@@ -4,6 +4,7 @@ import { createLogger } from '@sim/logger'
 import { toError } from '@sim/utils/errors'
 import { sleep } from '@sim/utils/helpers'
 import { and, eq, inArray, isNull } from 'drizzle-orm'
+import { normalizeStringRecord, normalizeWorkflowVariables } from '@/lib/core/utils/records'
 import { createMcpToolId } from '@/lib/mcp/utils'
 import { getCustomToolById } from '@/lib/workflows/custom-tools/operations'
 import { getAllBlocks } from '@/blocks'
@@ -815,8 +816,8 @@ export class AgentBlockHandler implements BlockHandler {
       userId: ctx.userId,
       stream: streaming,
       messages: messages?.map(({ executionId, ...msg }) => msg),
-      environmentVariables: ctx.environmentVariables || {},
-      workflowVariables: ctx.workflowVariables || {},
+      environmentVariables: normalizeStringRecord(ctx.environmentVariables),
+      workflowVariables: normalizeWorkflowVariables(ctx.workflowVariables),
       blockData,
       blockNameMapping,
       reasoningEffort: inputs.reasoningEffort,
@@ -885,8 +886,8 @@ export class AgentBlockHandler implements BlockHandler {
         userId: ctx.userId,
         stream: providerRequest.stream,
         messages: 'messages' in providerRequest ? providerRequest.messages : undefined,
-        environmentVariables: ctx.environmentVariables || {},
-        workflowVariables: ctx.workflowVariables || {},
+        environmentVariables: normalizeStringRecord(ctx.environmentVariables),
+        workflowVariables: normalizeWorkflowVariables(ctx.workflowVariables),
         blockData,
         blockNameMapping,
         isDeployedContext: ctx.isDeployedContext,
diff --git a/apps/sim/executor/handlers/condition/condition-handler.ts b/apps/sim/executor/handlers/condition/condition-handler.ts
@@ -1,4 +1,5 @@
 import { createLogger } from '@sim/logger'
+import { normalizeStringRecord, normalizeWorkflowVariables } from '@/lib/core/utils/records'
 import type { BlockOutput } from '@/blocks/types'
 import { BlockType, CONDITION, DEFAULTS, EDGE } from '@/executor/constants'
 import type { BlockHandler, ExecutionContext } from '@/executor/types'
@@ -40,8 +41,8 @@ export async function evaluateConditionExpression(
       {
         code,
         timeout: CONDITION_TIMEOUT_MS,
-        envVars: ctx.environmentVariables || {},
-        workflowVariables: ctx.workflowVariables || {},
+        envVars: normalizeStringRecord(ctx.environmentVariables),
+        workflowVariables: normalizeWorkflowVariables(ctx.workflowVariables),
         blockData,
         blockNameMapping,
         blockOutputSchemas,
diff --git a/apps/sim/executor/handlers/function/function-handler.test.ts b/apps/sim/executor/handlers/function/function-handler.test.ts
@@ -196,6 +196,28 @@ describe('FunctionBlockHandler', () => {
     )
   })
 
+  it('should normalize malformed execution context records before calling function_execute', async () => {
+    const legacyVariable = { id: 'var-1', name: 'brand', type: 'plain', value: 'myfitness' }
+    mockContext.workflowVariables = [legacyVariable] as unknown as Record<string, any>
+    mockContext.environmentVariables = ['invalid-env'] as unknown as Record<string, string>
+
+    await handler.execute(mockContext, mockBlock, {
+      code: 'return "myfitness"',
+      [FUNCTION_BLOCK_CONTEXT_VARS_KEY]: ['invalid-context'],
+    })
+
+    expect(mockExecuteTool).toHaveBeenCalledWith(
+      'function_execute',
+      expect.objectContaining({
+        envVars: {},
+        workflowVariables: { 'var-1': legacyVariable },
+        contextVariables: {},
+      }),
+      false,
+      mockContext
+    )
+  })
+
   it('should handle tool error with no specific message', async () => {
     const inputs = { code: 'some code' }
     const errorResult = { success: false }
diff --git a/apps/sim/executor/handlers/function/function-handler.ts b/apps/sim/executor/handlers/function/function-handler.ts
@@ -1,3 +1,8 @@
+import {
+  normalizeRecord,
+  normalizeStringRecord,
+  normalizeWorkflowVariables,
+} from '@/lib/core/utils/records'
 import { DEFAULT_EXECUTION_TIMEOUT_MS } from '@/lib/execution/constants'
 import { DEFAULT_CODE_LANGUAGE } from '@/lib/execution/languages'
 import { BlockType } from '@/executor/constants'
@@ -26,17 +31,16 @@ export class FunctionBlockHandler implements BlockHandler {
 
     const { blockData, blockNameMapping, blockOutputSchemas } = collectBlockData(ctx)
 
-    const contextVariables =
-      (inputs[FUNCTION_BLOCK_CONTEXT_VARS_KEY] as Record<string, unknown> | undefined) ?? {}
+    const contextVariables = normalizeRecord(inputs[FUNCTION_BLOCK_CONTEXT_VARS_KEY])
 
     const result = await executeTool(
       'function_execute',
       {
         code: codeContent,
         language: inputs.language || DEFAULT_CODE_LANGUAGE,
         timeout: inputs.timeout || DEFAULT_EXECUTION_TIMEOUT_MS,
-        envVars: ctx.environmentVariables || {},
-        workflowVariables: ctx.workflowVariables || {},
+        envVars: normalizeStringRecord(ctx.environmentVariables),
+        workflowVariables: normalizeWorkflowVariables(ctx.workflowVariables),
         blockData,
         blockNameMapping,
         blockOutputSchemas,
diff --git a/apps/sim/lib/core/utils/arrays.test.ts b/apps/sim/lib/core/utils/arrays.test.ts
@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest'
+import { normalizeStringArray } from '@/lib/core/utils/arrays'
+
+describe('array normalization utilities', () => {
+  it('normalizes string arrays loaded from untyped state', () => {
+    expect(normalizeStringArray(['output-1', 2, 'output-2', null])).toEqual([
+      'output-1',
+      'output-2',
+    ])
+    expect(normalizeStringArray('output-1')).toEqual([])
+    expect(normalizeStringArray(undefined)).toEqual([])
+  })
+})
diff --git a/apps/sim/lib/core/utils/arrays.ts b/apps/sim/lib/core/utils/arrays.ts
@@ -0,0 +1,10 @@
+/**
+ * Normalizes optional string-list values loaded from untyped persisted state.
+ */
+export function normalizeStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    return []
+  }
+
+  return value.filter((item): item is string => typeof item === 'string')
+}
diff --git a/apps/sim/lib/core/utils/records.test.ts b/apps/sim/lib/core/utils/records.test.ts
@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest'
+import {
+  isPlainRecord,
+  normalizeRecord,
+  normalizeRecordMap,
+  normalizeStringRecord,
+  normalizeWorkflowVariables,
+} from '@/lib/core/utils/records'
+
+describe('record normalization utilities', () => {
+  it('identifies plain records without accepting arrays or null', () => {
+    expect(isPlainRecord({})).toBe(true)
+    expect(isPlainRecord(Object.create(null))).toBe(true)
+    expect(isPlainRecord([])).toBe(false)
+    expect(isPlainRecord(null)).toBe(false)
+  })
+
+  it('normalizes unknown values to object records', () => {
+    expect(normalizeRecord({ value: 1 })).toEqual({ value: 1 })
+    expect(normalizeRecord([])).toEqual({})
+    expect(normalizeRecord('not-a-record')).toEqual({})
+  })
+
+  it('normalizes string records for environment-like values', () => {
+    expect(
+      normalizeStringRecord({
+        TOKEN: 'secret',
+        RETRIES: 3,
+        ENABLED: true,
+        EMPTY: null,
+      })
+    ).toEqual({
+      TOKEN: 'secret',
+      RETRIES: '3',
+      ENABLED: 'true',
+    })
+    expect(normalizeStringRecord([])).toEqual({})
+  })
+
+  it('normalizes record maps by dropping malformed entries', () => {
+    expect(
+      normalizeRecordMap({
+        valid: { type: 'string' },
+        invalid: [],
+      })
+    ).toEqual({
+      valid: { type: 'string' },
+    })
+  })
+
+  it('normalizes legacy workflow variable arrays into records', () => {
+    const variableWithId = { id: 'var-1', name: 'brand', type: 'plain', value: 'myfitness' }
+    const variableWithName = { name: 'channel', type: 'plain', value: 'whatsapp' }
+
+    expect(normalizeWorkflowVariables([variableWithId, variableWithName, []])).toEqual({
+      'var-1': variableWithId,
+      channel: variableWithName,
+    })
+    expect(normalizeWorkflowVariables({ existing: variableWithId })).toEqual({
+      existing: variableWithId,
+    })
+    expect(normalizeWorkflowVariables('not-a-record')).toEqual({})
+  })
+})
diff --git a/apps/sim/lib/core/utils/records.ts b/apps/sim/lib/core/utils/records.ts
diff --git a/apps/sim/lib/workflows/executor/execution-core.ts b/apps/sim/lib/workflows/executor/execution-core.ts
diff --git a/apps/sim/lib/workflows/executor/queued-workflow-execution.ts b/apps/sim/lib/workflows/executor/queued-workflow-execution.ts
diff --git a/apps/sim/providers/utils.ts b/apps/sim/providers/utils.ts
diff --git a/apps/sim/tools/function/execute.ts b/apps/sim/tools/function/execute.ts
diff --git a/apps/sim/tools/utils.ts b/apps/sim/tools/utils.ts
