improvement(resolver): use context variables for block outputs in function block code

apps/sim/app/api/function/execute/route.ts

@@ -587,6 +587,26 @@ function cleanStdout(stdout: string): string {
   return stdout
 }
 
+/**
+ * Serializes a value for use as a shell environment variable. Strings pass through
+ * unchanged; primitives are coerced via `String`; objects, arrays, and other complex
+ * values are JSON-stringified so that referencing them via `$VAR` yields a useful
+ * representation instead of `[object Object]`. `null`/`undefined` become an empty
+ * string to match POSIX env semantics.
+ */
+function serializeForShellEnv(value: unknown, nullValue = ''): string {
+  if (value === null || value === undefined) return nullValue
+  if (typeof value === 'string') return value
+  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+    return String(value)
+  }
+  try {
+    return JSON.stringify(value) ?? ''
+  } catch {
+    return String(value)
+  }
+}
+
 async function maybeExportSandboxFileToWorkspace(args: {
   authUserId: string
   workflowId?: string
@@ -722,6 +742,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
       blockNameMapping = {},
       blockOutputSchemas = {},
       workflowVariables = {},
+      contextVariables: preResolvedContextVariables = {},
       workflowId,
       workspaceId,
       isCustomTool = false,
@@ -746,6 +767,10 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
       // For shell, env vars are injected as OS env vars via shellEnvs.
       // Replace {{VAR}} placeholders with $VAR so the shell can access them natively.
       resolvedCode = code.replace(/\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}/g, '$$$1')
+      // Carry pre-resolved block output variables (e.g. __blockRef_N) so they can be
+      // injected as shell env vars below. The executor replaces block references in the
+      // code with these names, so the values must be present at runtime.
+      contextVariables = { ...preResolvedContextVariables }
     } else {
       const codeResolution = resolveCodeVariables(
         code,
@@ -758,7 +783,10 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
         lang
       )
       resolvedCode = codeResolution.resolvedCode
-      contextVariables = codeResolution.contextVariables
+      // Merge pre-resolved block output variables from the executor. These take precedence
+      // because they were produced by the resolver using full execution-state context
+      // (including loop/parallel scope) and should not be overwritten.
+      contextVariables = { ...codeResolution.contextVariables, ...preResolvedContextVariables }
     }
 
     let jsImports = ''
@@ -783,10 +811,10 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
 
       const shellEnvs: Record<string, string> = {}
       for (const [k, v] of Object.entries(envVars)) {
-        shellEnvs[k] = String(v)
+        shellEnvs[k] = serializeForShellEnv(v)
       }
       for (const [k, v] of Object.entries(contextVariables)) {
-        shellEnvs[k] = String(v)
+        shellEnvs[k] = serializeForShellEnv(v, 'null')
       }
 
       logger.info(`[${requestId}] E2B shell execution`, {
@@ -893,7 +921,9 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
         prologue += `const environmentVariables = JSON.parse(${JSON.stringify(JSON.stringify(envVars))});\n`
         prologueLineCount++
         for (const [k, v] of Object.entries(contextVariables)) {
-          prologue += `const ${k} = ${formatLiteralForCode(v, 'javascript')};\n`
+          prologue += `globalThis[${JSON.stringify(k)}] = ${formatLiteralForCode(v, 'javascript')};\n`
+          prologue += `const ${k} = globalThis[${JSON.stringify(k)}];\n`
+          prologueLineCount++
           prologueLineCount++
         }
 

apps/sim/executor/execution/block-executor.ts

@@ -44,7 +44,10 @@ import {
 } from '@/executor/utils/iteration-context'
 import { isJSONString } from '@/executor/utils/json'
 import { filterOutputForLog } from '@/executor/utils/output-filter'
-import type { VariableResolver } from '@/executor/variables/resolver'
+import {
+  FUNCTION_BLOCK_CONTEXT_VARS_KEY,
+  type VariableResolver,
+} from '@/executor/variables/resolver'
 import type { SerializedBlock } from '@/serializer/types'
 import { SYSTEM_SUBBLOCK_IDS } from '@/triggers/constants'
 
@@ -115,7 +118,13 @@ export class BlockExecutor {
         await validateBlockType(ctx.userId, ctx.workspaceId, blockType, ctx)
       }
 
-      resolvedInputs = this.resolver.resolveInputs(ctx, node.id, block.config.params, block)
+      if (block.metadata?.id === BlockType.FUNCTION) {
+        const { resolvedInputs: fnInputs, contextVariables } =
+          this.resolver.resolveInputsForFunctionBlock(ctx, node.id, block.config.params, block)
+        resolvedInputs = { ...fnInputs, [FUNCTION_BLOCK_CONTEXT_VARS_KEY]: contextVariables }
+      } else {
+        resolvedInputs = this.resolver.resolveInputs(ctx, node.id, block.config.params, block)
+      }
 
       if (blockLog) {
         blockLog.input = this.sanitizeInputsForLog(resolvedInputs)
@@ -428,7 +437,11 @@ export class BlockExecutor {
     const result: Record<string, any> = {}
 
     for (const [key, value] of Object.entries(inputs)) {
-      if (SYSTEM_SUBBLOCK_IDS.includes(key) || key === 'triggerMode') {
+      if (
+        SYSTEM_SUBBLOCK_IDS.includes(key) ||
+        key === 'triggerMode' ||
+        key === FUNCTION_BLOCK_CONTEXT_VARS_KEY
+      ) {
         continue
       }
 

apps/sim/executor/handlers/function/function-handler.test.ts

@@ -3,6 +3,7 @@ import { DEFAULT_EXECUTION_TIMEOUT_MS } from '@/lib/execution/constants'
 import { BlockType } from '@/executor/constants'
 import { FunctionBlockHandler } from '@/executor/handlers/function/function-handler'
 import type { ExecutionContext } from '@/executor/types'
+import { FUNCTION_BLOCK_CONTEXT_VARS_KEY } from '@/executor/variables/resolver'
 import type { SerializedBlock } from '@/serializer/types'
 import { executeTool } from '@/tools'
 
@@ -73,10 +74,13 @@ describe('FunctionBlockHandler', () => {
       blockData: {},
       blockNameMapping: {},
       blockOutputSchemas: {},
+      contextVariables: {},
       _context: {
         workflowId: mockContext.workflowId,
         workspaceId: mockContext.workspaceId,
+        userId: mockContext.userId,
         isDeployedContext: mockContext.isDeployedContext,
+        enforceCredentialAccess: mockContext.enforceCredentialAccess,
       },
     }
     const expectedOutput: any = { result: 'Success' }
@@ -110,10 +114,13 @@ describe('FunctionBlockHandler', () => {
       blockData: {},
       blockNameMapping: {},
       blockOutputSchemas: {},
+      contextVariables: {},
       _context: {
         workflowId: mockContext.workflowId,
         workspaceId: mockContext.workspaceId,
+        userId: mockContext.userId,
         isDeployedContext: mockContext.isDeployedContext,
+        enforceCredentialAccess: mockContext.enforceCredentialAccess,
       },
     }
     const expectedOutput: any = { result: 'Success' }
@@ -140,10 +147,13 @@ describe('FunctionBlockHandler', () => {
       blockData: {},
       blockNameMapping: {},
       blockOutputSchemas: {},
+      contextVariables: {},
       _context: {
         workflowId: mockContext.workflowId,
         workspaceId: mockContext.workspaceId,
+        userId: mockContext.userId,
         isDeployedContext: mockContext.isDeployedContext,
+        enforceCredentialAccess: mockContext.enforceCredentialAccess,
       },
     }
 
@@ -168,6 +178,24 @@ describe('FunctionBlockHandler', () => {
     expect(mockExecuteTool).toHaveBeenCalled()
   })
 
+  it('should pass runtime context variables to function_execute', async () => {
+    const contextVariables = { __blockRef_0: { result: 'from-block' } }
+
+    await handler.execute(mockContext, mockBlock, {
+      code: 'return globalThis["__blockRef_0"]',
+      [FUNCTION_BLOCK_CONTEXT_VARS_KEY]: contextVariables,
+    })
+
+    expect(mockExecuteTool).toHaveBeenCalledWith(
+      'function_execute',
+      expect.objectContaining({
+        contextVariables,
+      }),
+      false,
+      mockContext
+    )
+  })
+
   it('should handle tool error with no specific message', async () => {
     const inputs = { code: 'some code' }
     const errorResult = { success: false }

apps/sim/executor/handlers/function/function-handler.ts

@@ -3,6 +3,7 @@ import { DEFAULT_CODE_LANGUAGE } from '@/lib/execution/languages'
 import { BlockType } from '@/executor/constants'
 import type { BlockHandler, ExecutionContext } from '@/executor/types'
 import { collectBlockData } from '@/executor/utils/block-data'
+import { FUNCTION_BLOCK_CONTEXT_VARS_KEY } from '@/executor/variables/resolver'
 import type { SerializedBlock } from '@/serializer/types'
 import { executeTool } from '@/tools'
 
@@ -25,6 +26,9 @@ 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 result = await executeTool(
       'function_execute',
       {
@@ -36,6 +40,7 @@ export class FunctionBlockHandler implements BlockHandler {
         blockData,
         blockNameMapping,
         blockOutputSchemas,
+        contextVariables,
         _context: {
           workflowId: ctx.workflowId,
           workspaceId: ctx.workspaceId,

apps/sim/executor/utils/reference-validation.ts

@@ -143,14 +143,14 @@ export function createCombinedPattern(): RegExp {
  */
 export function replaceValidReferences(
   template: string,
-  replacer: (match: string) => string
+  replacer: (match: string, index: number, template: string) => string
 ): string {
   const pattern = createReferencePattern()
 
-  return template.replace(pattern, (match) => {
+  return template.replace(pattern, (match, _content, index) => {
     if (!isLikelyReferenceSegment(match)) {
       return match
     }
-    return replacer(match)
+    return replacer(match, index, template)
   })
 }

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

@@ -0,0 +1,153 @@
+/**
+ * @vitest-environment node
+ */
+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 createBlock(id: string, name: string, type: string, params = {}): SerializedBlock {
+  return {
+    id,
+    metadata: { id: type, name },
+    position: { x: 0, y: 0 },
+    config: { tool: type, params },
+    inputs: {},
+    outputs: {
+      result: 'string',
+      items: 'json',
+    },
+    enabled: true,
+  }
+}
+
+function createResolver(language = 'javascript') {
+  const producer = createBlock('producer', 'Producer', BlockType.API)
+  const functionBlock = createBlock('function', 'Function', BlockType.FUNCTION, {
+    language,
+  })
+  const workflow: SerializedWorkflow = {
+    version: '1',
+    blocks: [producer, functionBlock],
+    connections: [],
+    loops: {},
+    parallels: {},
+  }
+  const state = new ExecutionState()
+  state.setBlockOutput('producer', {
+    result: 'hello world',
+    items: ['a', 'b'],
+  })
+  const ctx = {
+    blockStates: state.getBlockStates(),
+    blockLogs: [],
+    environmentVariables: {},
+    workflowVariables: {},
+    decisions: { router: new Map(), condition: new Map() },
+    loopExecutions: new Map(),
+    executedBlocks: new Set(),
+    activeExecutionPath: new Set(),
+    completedLoops: new Set(),
+    metadata: {},
+  } as ExecutionContext
+
+  return {
+    block: functionBlock,
+    ctx,
+    resolver: new VariableResolver(workflow, {}, state),
+  }
+}
+
+describe('VariableResolver function block inputs', () => {
+  it('returns empty inputs when params are missing', () => {
+    const { block, ctx, resolver } = createResolver()
+
+    const result = resolver.resolveInputsForFunctionBlock(ctx, 'function', undefined, block)
+
+    expect(result).toEqual({ resolvedInputs: {}, contextVariables: {} })
+  })
+
+  it('resolves JavaScript block references through globalThis context variables', () => {
+    const { block, ctx, resolver } = createResolver('javascript')
+
+    const result = resolver.resolveInputsForFunctionBlock(
+      ctx,
+      'function',
+      { code: 'return <Producer.result>' },
+      block
+    )
+
+    expect(result.resolvedInputs.code).toBe('return globalThis["__blockRef_0"]')
+    expect(result.contextVariables).toEqual({ __blockRef_0: 'hello world' })
+  })
+
+  it('resolves Python block references through globals lookup', () => {
+    const { block, ctx, resolver } = createResolver('python')
+
+    const result = resolver.resolveInputsForFunctionBlock(
+      ctx,
+      'function',
+      { code: 'return <Producer.result>' },
+      block
+    )
+
+    expect(result.resolvedInputs.code).toBe('return globals()["__blockRef_0"]')
+    expect(result.contextVariables).toEqual({ __blockRef_0: 'hello world' })
+  })
+
+  it('uses separate Python context variables for repeated mutable references', () => {
+    const { block, ctx, resolver } = createResolver('python')
+
+    const result = resolver.resolveInputsForFunctionBlock(
+      ctx,
+      'function',
+      { code: 'a = <Producer.items>\nb = <Producer.items>\nreturn b' },
+      block
+    )
+
+    expect(result.resolvedInputs.code).toBe(
+      'a = globals()["__blockRef_0"]\nb = globals()["__blockRef_1"]\nreturn b'
+    )
+    expect(result.contextVariables).toEqual({
+      __blockRef_0: ['a', 'b'],
+      __blockRef_1: ['a', 'b'],
+    })
+  })
+
+  it('uses shell-safe expansions for block references', () => {
+    const { block, ctx, resolver } = createResolver('shell')
+
+    const result = resolver.resolveInputsForFunctionBlock(
+      ctx,
+      'function',
+      { code: 'echo <Producer.result>suffix && echo "<Producer.result>"' },
+      block
+    )
+
+    expect(result.resolvedInputs.code).toBe(
+      `echo "\${__blockRef_0}"suffix && echo "\${__blockRef_1}"`
+    )
+    expect(result.contextVariables).toEqual({
+      __blockRef_0: 'hello world',
+      __blockRef_1: 'hello world',
+    })
+  })
+
+  it('ignores shell comment quotes when formatting later block references', () => {
+    const { block, ctx, resolver } = createResolver('shell')
+
+    const result = resolver.resolveInputsForFunctionBlock(
+      ctx,
+      'function',
+      { code: "# don't confuse quote tracking\necho <Producer.result>" },
+      block
+    )
+
+    expect(result.resolvedInputs.code).toBe(
+      `# don't confuse quote tracking\necho "\${__blockRef_0}"`
+    )
+    expect(result.contextVariables).toEqual({ __blockRef_0: 'hello world' })
+  })
+})