fix: use context variables for block outputs in function block code

When a function block references another block's output via <BlockA.result>,
the executor previously embedded the full value as a JavaScript literal
directly in the code string. For large outputs (>50 KB), this caused the code
string to exceed the terminal console display limit, making inputs appear
truncated or replaced with { __simTruncated: true } in the UI.

Instead, block output references in function block code are now stored as
named global variables (__blockRef_N) in the isolated VM context. The code
string only contains the compact variable name, keeping it small regardless
of the referenced value size.

Loop/parallel/env/workflow references are still inlined as literals since
the API route has no way to resolve them independently.

The _runtimeContextVars key is filtered from sanitizeInputsForLog so it
does not appear in execution logs or SSE events.

Pre-resolved context variables are merged with any variables produced by
the API route resolveCodeVariables, with executor values taking precedence.

Fixes #4195

Author: octo-patch

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

@@ -719,6 +719,7 @@ export async function POST(req: NextRequest) {
       blockNameMapping = {},
       blockOutputSchemas = {},
       workflowVariables = {},
+      contextVariables: preResolvedContextVariables = {},
       workflowId,
       workspaceId,
       isCustomTool = false,
@@ -755,7 +756,10 @@ export async function POST(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 = ''

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

@@ -42,7 +42,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'
 
@@ -108,7 +111,13 @@ export class BlockExecutor {
         await validateBlockType(ctx.userId, 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)
@@ -418,7 +427,7 @@ 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.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,10 @@ 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 +41,7 @@ export class FunctionBlockHandler implements BlockHandler {
         blockData,
         blockNameMapping,
         blockOutputSchemas,
+        contextVariables,
         _context: {
           workflowId: ctx.workflowId,
           workspaceId: ctx.workspaceId,

apps/sim/executor/variables/resolver.ts

@@ -15,6 +15,9 @@ import {
 import { WorkflowResolver } from '@/executor/variables/resolvers/workflow'
 import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
 
+/** Key used to carry pre-resolved context variables through the inputs map. */
+export const FUNCTION_BLOCK_CONTEXT_VARS_KEY = '_runtimeContextVars'
+
 const logger = createLogger('VariableResolver')
 
 export class VariableResolver {
@@ -36,6 +39,63 @@ export class VariableResolver {
     ]
   }
 
+  /**
+   * Resolves inputs for function blocks. Block output references in the `code` field
+   * are stored as named context variables instead of being embedded as JavaScript
+   * literals, preventing large values from bloating the code string.
+   *
+   * Returns the resolved inputs and a `contextVariables` map. Callers should inject
+   * contextVariables into the function execution request body so the isolated VM can
+   * access them as global variables.
+   */
+  resolveInputsForFunctionBlock(
+    ctx: ExecutionContext,
+    currentNodeId: string,
+    params: Record<string, any>,
+    block: SerializedBlock
+  ): { resolvedInputs: Record<string, any>; contextVariables: Record<string, unknown> } {
+    const contextVariables: Record<string, unknown> = {}
+    const resolved: Record<string, any> = {}
+
+    for (const [key, value] of Object.entries(params)) {
+      if (key === 'code') {
+        if (typeof value === 'string') {
+          resolved[key] = this.resolveCodeWithContextVars(
+            ctx,
+            currentNodeId,
+            value,
+            undefined,
+            block,
+            contextVariables
+          )
+        } else if (Array.isArray(value)) {
+          resolved[key] = value.map((item: any) => {
+            if (item && typeof item === 'object' && typeof item.content === 'string') {
+              return {
+                ...item,
+                content: this.resolveCodeWithContextVars(
+                  ctx,
+                  currentNodeId,
+                  item.content,
+                  undefined,
+                  block,
+                  contextVariables
+                ),
+              }
+            }
+            return item
+          })
+        } else {
+          resolved[key] = this.resolveValue(ctx, currentNodeId, value, undefined, block)
+        }
+      } else {
+        resolved[key] = this.resolveValue(ctx, currentNodeId, value, undefined, block)
+      }
+    }
+
+    return { resolvedInputs: resolved, contextVariables }
+  }
+
   resolveInputs(
     ctx: ExecutionContext,
     currentNodeId: string,
@@ -149,6 +209,70 @@ export class VariableResolver {
     }
     return value
   }
+  /**
+   * Resolves a code template for a function block. Block output references are stored
+   * in `contextVarAccumulator` as named variables (e.g. `__blockRef_0`) and replaced
+   * with those variable names in the returned code string. Non-block references (loop
+   * items, workflow variables, env vars) are still inlined as literals so they remain
+   * available without any extra passing mechanism.
+   */
+  private resolveCodeWithContextVars(
+    ctx: ExecutionContext,
+    currentNodeId: string,
+    template: string,
+    loopScope: LoopScope | undefined,
+    block: SerializedBlock,
+    contextVarAccumulator: Record<string, unknown>
+  ): string {
+    const resolutionContext: ResolutionContext = {
+      executionContext: ctx,
+      executionState: this.state,
+      currentNodeId,
+      loopScope,
+    }
+
+    const language = (block.config?.params as Record<string, unknown> | undefined)?.language as
+      | string
+      | undefined
+
+    let replacementError: Error | null = null
+
+    let result = replaceValidReferences(template, (match) => {
+      if (replacementError) return match
+
+      try {
+        const resolved = this.resolveReference(match, resolutionContext)
+        if (resolved === undefined) return match
+
+        const effectiveValue = resolved === RESOLVED_EMPTY ? null : resolved
+
+        if (this.blockResolver.canResolve(match)) {
+          // Block output: store in contextVarAccumulator, replace with variable name
+          const varName = `__blockRef_${Object.keys(contextVarAccumulator).length}`
+          contextVarAccumulator[varName] = effectiveValue
+          return varName
+        }
+
+        // Non-block reference (loop, parallel, workflow, env): embed as literal
+        return this.blockResolver.formatValueForBlock(effectiveValue, BlockType.FUNCTION, language)
+      } catch (error) {
+        replacementError = error instanceof Error ? error : new Error(String(error))
+        return match
+      }
+    })
+
+    if (replacementError !== null) {
+      throw replacementError
+    }
+
+    result = result.replace(createEnvVarPattern(), (match) => {
+      const resolved = this.resolveReference(match, resolutionContext)
+      return typeof resolved === 'string' ? resolved : match
+    })
+
+    return result
+  }
+
   private resolveTemplate(
     ctx: ExecutionContext,
     currentNodeId: string,

apps/sim/tools/function/execute.ts

@@ -128,6 +128,7 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
         blockData: params.blockData || {},
         blockNameMapping: params.blockNameMapping || {},
         blockOutputSchemas: params.blockOutputSchemas || {},
+        contextVariables: params.contextVariables || {},
         workflowId: params._context?.workflowId,
         userId: params._context?.userId,
         workspaceId: params._context?.workspaceId,

apps/sim/tools/function/types.ts

@@ -17,6 +17,8 @@ export interface CodeExecutionInput {
   blockData?: Record<string, unknown>
   blockNameMapping?: Record<string, string>
   blockOutputSchemas?: Record<string, Record<string, unknown>>
+  /** Pre-resolved block output variables from the executor, injected as VM globals. */
+  contextVariables?: Record<string, unknown>
   _context?: {
     workflowId?: string
     userId?: string
@@ -32,3 +34,10 @@ export interface CodeExecutionOutput extends ToolResponse {
     stdout: string
   }
 }
+
+export interface CodeExecutionOutput extends ToolResponse {
+  output: {
+    result: any
+    stdout: string
+  }
+}