fix(custom-blocks): share one large-value id list so nested blocks propagate

Author: TheodoreSpeaks

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

@@ -1130,6 +1130,30 @@ describe('WorkflowBlockHandler', () => {
       expect(ctx.largeValueExecutionIds).toContain(extensions.executionId)
     })
 
+    it('shares one large-value id list so nested custom blocks propagate upward', async () => {
+      const ctx = customBlockContext()
+      await handler.execute(ctx, customBlock(), {})
+
+      const childIds = executorOptions[0].contextExtensions.largeValueExecutionIds
+      // Same array instance, not a copy — that is what lets a nested custom
+      // block's grandchild id reach the top-level invoker.
+      expect(childIds).toBe(ctx.largeValueExecutionIds)
+
+      // Simulate a nested custom block appending its own child id deeper down.
+      childIds.push('grandchild-execution-id')
+      expect(ctx.largeValueExecutionIds).toContain('grandchild-execution-id')
+    })
+
+    it('does not duplicate ids across repeated invocations', async () => {
+      const ctx = customBlockContext()
+      await handler.execute(ctx, customBlock(), {})
+      await handler.execute(ctx, customBlock(), {})
+
+      const ids = ctx.largeValueExecutionIds as string[]
+      expect(new Set(ids).size).toBe(ids.length)
+      expect(ids.filter((id) => id === 'parent-execution-id')).toHaveLength(1)
+    })
+
     it('never forwards the consumer SSE callbacks into the source run', async () => {
       const ctx = customBlockContext({
         onBlockStart: vi.fn(),

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

@@ -255,6 +255,8 @@ export class WorkflowBlockHandler implements BlockHandler {
     let childSessionStarted = false
     /** Set once the child's session reached a terminal state, so the catch doesn't re-complete it. */
     let childSessionFinalized = false
+    /** Large-value id list shared with the child (and any nested custom blocks). */
+    let sharedLargeValueIds: string[] | undefined
     let childCancellation: { signal: AbortSignal; dispose: () => void } | undefined
     try {
       // A custom block runs the source's latest deployment; if the source has been
@@ -467,10 +469,16 @@ export class WorkflowBlockHandler implements BlockHandler {
           parentExecutionId: ctx.executionId,
         })
         // Large values are scoped by execution id, so the parent must be able to
-        // read a large exposed output the child produced.
-        ctx.largeValueExecutionIds = Array.from(
-          new Set([...(ctx.largeValueExecutionIds ?? []), childExecutionId])
-        )
+        // read a large exposed output the child produced. ONE array is shared down
+        // the whole chain rather than copied per hop: a nested custom block pushes
+        // its own child id into this same list, so a grandchild's large output is
+        // still materializable at the top level. Copying would strand those ids at
+        // the depth that created them.
+        ctx.largeValueExecutionIds ??= []
+        sharedLargeValueIds = ctx.largeValueExecutionIds
+        for (const id of [ctx.executionId, childExecutionId]) {
+          if (id && !sharedLargeValueIds.includes(id)) sharedLargeValueIds.push(id)
+        }
       }
 
       // Trusted run metadata for the child's Start block. Every field describes
@@ -525,15 +533,8 @@ export class WorkflowBlockHandler implements BlockHandler {
           executionId: childExecutionId ?? ctx.executionId,
           // Large values are cached per execution id, so a child running under its
           // own id still needs the invoking run's id to read values in its inputs.
-          ...(childExecutionId
-            ? {
-                largeValueExecutionIds: Array.from(
-                  new Set([
-                    ...(ctx.executionId ? [ctx.executionId] : []),
-                    ...(ctx.largeValueExecutionIds ?? []),
-                  ])
-                ),
-              }
+          ...(childExecutionId && sharedLargeValueIds
+            ? { largeValueExecutionIds: sharedLargeValueIds }
             : {}),
           // Same-workspace children share the parent's frozen payer decision so
           // internal tool calls (knowledge, guardrails, MCP, Mothership) can