feat(terminal): real-time child workflow block propagation in console

waleedlatif1 · waleedlatif1 · commit f4f293aaa0fc · 2026-02-22T23:40:51.000-08:00
diff --git a/apps/sim/app/api/workflows/[id]/execute/route.ts b/apps/sim/app/api/workflows/[id]/execute/route.ts
@@ -919,12 +919,34 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
             selectedOutputs
           )
 
+          const onChildWorkflowInstanceReady = (
+            blockId: string,
+            childWorkflowInstanceId: string,
+            iterationContext?: IterationContext
+          ) => {
+            sendEvent({
+              type: 'block:childWorkflowStarted',
+              timestamp: new Date().toISOString(),
+              executionId,
+              workflowId,
+              data: {
+                blockId,
+                childWorkflowInstanceId,
+                ...(iterationContext && {
+                  iterationCurrent: iterationContext.iterationCurrent,
+                  iterationContainerId: iterationContext.iterationContainerId,
+                }),
+              },
+            })
+          }
+
           const result = await executeWorkflowCore({
             snapshot,
             callbacks: {
               onBlockStart,
               onBlockComplete,
               onStream,
+              onChildWorkflowInstanceReady,
             },
             loggingSession,
             abortSignal: timeoutController.signal,
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution.ts b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution.ts
@@ -549,7 +549,27 @@ export function useWorkflowExecution() {
         }
       }
 
-      return { onBlockStarted, onBlockCompleted, onBlockError }
+      const onBlockChildWorkflowStarted = (data: {
+        blockId: string
+        childWorkflowInstanceId: string
+        iterationCurrent?: number
+        iterationContainerId?: string
+      }) => {
+        if (isStaleExecution()) return
+        updateConsole(
+          data.blockId,
+          {
+            childWorkflowInstanceId: data.childWorkflowInstanceId,
+            ...(data.iterationCurrent !== undefined && { iterationCurrent: data.iterationCurrent }),
+            ...(data.iterationContainerId !== undefined && {
+              iterationContainerId: data.iterationContainerId,
+            }),
+          },
+          executionIdRef.current
+        )
+      }
+
+      return { onBlockStarted, onBlockCompleted, onBlockError, onBlockChildWorkflowStarted }
     },
     [addConsole, setActiveBlocks, setBlockRunStatus, setEdgeRunStatus, updateConsole]
   )
@@ -1349,6 +1369,7 @@ export function useWorkflowExecution() {
             onBlockStarted: blockHandlers.onBlockStarted,
             onBlockCompleted: blockHandlers.onBlockCompleted,
             onBlockError: blockHandlers.onBlockError,
+            onBlockChildWorkflowStarted: blockHandlers.onBlockChildWorkflowStarted,
 
             onStreamChunk: (data) => {
               const existing = streamedContent.get(data.blockId) || ''
@@ -1946,6 +1967,7 @@ export function useWorkflowExecution() {
             onBlockStarted: blockHandlers.onBlockStarted,
             onBlockCompleted: blockHandlers.onBlockCompleted,
             onBlockError: blockHandlers.onBlockError,
+            onBlockChildWorkflowStarted: blockHandlers.onBlockChildWorkflowStarted,
 
             onExecutionCompleted: (data) => {
               if (data.success) {
@@ -2174,6 +2196,10 @@ export function useWorkflowExecution() {
             clearOnce()
             handlers.onBlockError(data)
           },
+          onBlockChildWorkflowStarted: (data) => {
+            clearOnce()
+            handlers.onBlockChildWorkflowStarted(data)
+          },
           onExecutionCompleted: () => {
             const currentId = useExecutionStore
               .getState()
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils.ts b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils.ts
@@ -220,6 +220,24 @@ export async function executeWorkflowWithFullLogging(
               break
             }
 
+            case 'block:childWorkflowStarted': {
+              const { updateConsole } = useTerminalConsoleStore.getState()
+              updateConsole(
+                event.data.blockId,
+                {
+                  childWorkflowInstanceId: event.data.childWorkflowInstanceId,
+                  ...(event.data.iterationCurrent !== undefined && {
+                    iterationCurrent: event.data.iterationCurrent,
+                  }),
+                  ...(event.data.iterationContainerId !== undefined && {
+                    iterationContainerId: event.data.iterationContainerId,
+                  }),
+                },
+                executionId
+              )
+              break
+            }
+
             case 'execution:completed':
               executionResult = {
                 success: event.data.success,
diff --git a/apps/sim/executor/execution/block-executor.ts b/apps/sim/executor/execution/block-executor.ts
@@ -208,6 +208,8 @@ export class BlockExecutor {
     parallelId?: string
     branchIndex?: number
     branchTotal?: number
+    originalBlockId?: string
+    isLoopNode?: boolean
   } {
     const metadata = node?.metadata ?? {}
     return {
@@ -216,6 +218,8 @@ export class BlockExecutor {
       parallelId: metadata.parallelId,
       branchIndex: metadata.branchIndex,
       branchTotal: metadata.branchTotal,
+      originalBlockId: metadata.originalBlockId,
+      isLoopNode: metadata.isLoopNode,
     }
   }
 
diff --git a/apps/sim/executor/execution/executor.ts b/apps/sim/executor/execution/executor.ts
@@ -322,6 +322,7 @@ export class DAGExecutor {
       onStream: this.contextExtensions.onStream,
       onBlockStart: this.contextExtensions.onBlockStart,
       onBlockComplete: this.contextExtensions.onBlockComplete,
+      onChildWorkflowInstanceReady: this.contextExtensions.onChildWorkflowInstanceReady,
       abortSignal: this.contextExtensions.abortSignal,
       childWorkflowContext: this.contextExtensions.childWorkflowContext,
       includeFileBase64: this.contextExtensions.includeFileBase64,
diff --git a/apps/sim/executor/execution/types.ts b/apps/sim/executor/execution/types.ts
@@ -83,6 +83,12 @@ export interface ExecutionCallbacks {
     iterationContext?: IterationContext,
     childWorkflowContext?: ChildWorkflowContext
   ) => Promise<void>
+  /** Fires immediately after instanceId is generated, before child execution begins. */
+  onChildWorkflowInstanceReady?: (
+    blockId: string,
+    childWorkflowInstanceId: string,
+    iterationContext?: IterationContext
+  ) => void
 }
 
 export interface ContextExtensions {
@@ -142,6 +148,13 @@ export interface ContextExtensions {
   /** Context identifying this execution as a child of a workflow block */
   childWorkflowContext?: ChildWorkflowContext
 
+  /** Fires immediately after instanceId is generated, before child execution begins. */
+  onChildWorkflowInstanceReady?: (
+    blockId: string,
+    childWorkflowInstanceId: string,
+    iterationContext?: IterationContext
+  ) => void
+
   /**
    * Run-from-block configuration. When provided, executor runs in partial
    * execution mode starting from the specified block.
diff --git a/apps/sim/executor/handlers/workflow/workflow-handler.ts b/apps/sim/executor/handlers/workflow/workflow-handler.ts
@@ -6,6 +6,7 @@ import type { BlockOutput } from '@/blocks/types'
 import { Executor } from '@/executor'
 import { BlockType, DEFAULTS, HTTP } from '@/executor/constants'
 import { ChildWorkflowError } from '@/executor/errors/child-workflow-error'
+import type { IterationContext } from '@/executor/execution/types'
 import type {
   BlockHandler,
   ExecutionContext,
@@ -44,6 +45,40 @@ export class WorkflowBlockHandler implements BlockHandler {
     ctx: ExecutionContext,
     block: SerializedBlock,
     inputs: Record<string, any>
+  ): Promise<BlockOutput | StreamingExecution> {
+    return this._executeCore(ctx, block, inputs)
+  }
+
+  async executeWithNode(
+    ctx: ExecutionContext,
+    block: SerializedBlock,
+    inputs: Record<string, any>,
+    nodeMetadata: {
+      nodeId: string
+      loopId?: string
+      parallelId?: string
+      branchIndex?: number
+      branchTotal?: number
+      originalBlockId?: string
+      isLoopNode?: boolean
+    }
+  ): Promise<BlockOutput | StreamingExecution> {
+    return this._executeCore(ctx, block, inputs, nodeMetadata)
+  }
+
+  private async _executeCore(
+    ctx: ExecutionContext,
+    block: SerializedBlock,
+    inputs: Record<string, any>,
+    nodeMetadata?: {
+      nodeId: string
+      loopId?: string
+      parallelId?: string
+      branchIndex?: number
+      branchTotal?: number
+      originalBlockId?: string
+      isLoopNode?: boolean
+    }
   ): Promise<BlockOutput | StreamingExecution> {
     logger.info(`Executing workflow block: ${block.id}`)
 
@@ -122,6 +157,12 @@ export class WorkflowBlockHandler implements BlockHandler {
       const childDepth = (ctx.childWorkflowContext?.depth ?? 0) + 1
       const shouldPropagateCallbacks = childDepth <= DEFAULTS.MAX_SSE_CHILD_DEPTH
 
+      if (nodeMetadata && shouldPropagateCallbacks) {
+        const effectiveBlockId = nodeMetadata.originalBlockId ?? nodeMetadata.nodeId
+        const iterationContext = this.getIterationContext(ctx, nodeMetadata)
+        ctx.onChildWorkflowInstanceReady?.(effectiveBlockId, instanceId, iterationContext)
+      }
+
       const subExecutor = new Executor({
         workflow: childWorkflow.serializedState,
         workflowInput: childWorkflowInput,
@@ -138,6 +179,7 @@ export class WorkflowBlockHandler implements BlockHandler {
             onBlockStart: ctx.onBlockStart,
             onBlockComplete: ctx.onBlockComplete,
             onStream: ctx.onStream as ((streamingExecution: unknown) => Promise<void>) | undefined,
+            onChildWorkflowInstanceReady: ctx.onChildWorkflowInstanceReady,
             childWorkflowContext: {
               parentBlockId: instanceId,
               workflowName: childWorkflowName,
@@ -208,6 +250,40 @@ export class WorkflowBlockHandler implements BlockHandler {
     }
   }
 
+  private getIterationContext(
+    ctx: ExecutionContext,
+    nodeMetadata: {
+      loopId?: string
+      parallelId?: string
+      branchIndex?: number
+      branchTotal?: number
+      isLoopNode?: boolean
+    }
+  ): IterationContext | undefined {
+    if (nodeMetadata.branchIndex !== undefined && nodeMetadata.parallelId !== undefined) {
+      return {
+        iterationCurrent: nodeMetadata.branchIndex,
+        iterationTotal: nodeMetadata.branchTotal,
+        iterationType: 'parallel',
+        iterationContainerId: nodeMetadata.parallelId,
+      }
+    }
+
+    if (nodeMetadata.isLoopNode && nodeMetadata.loopId) {
+      const loopScope = ctx.loopExecutions?.get(nodeMetadata.loopId)
+      if (loopScope && loopScope.iteration !== undefined) {
+        return {
+          iterationCurrent: loopScope.iteration,
+          iterationTotal: loopScope.maxIterations,
+          iterationType: 'loop',
+          iterationContainerId: nodeMetadata.loopId,
+        }
+      }
+    }
+
+    return undefined
+  }
+
   /**
    * Builds a cleaner error message for nested workflow errors.
    * Parses nested error messages to extract workflow chain and root error.
diff --git a/apps/sim/executor/types.ts b/apps/sim/executor/types.ts
@@ -259,6 +259,13 @@ export interface ExecutionContext {
   /** Context identifying this execution as a child of a workflow block */
   childWorkflowContext?: ChildWorkflowContext
 
+  /** Fires immediately after instanceId is generated, before child execution begins. */
+  onChildWorkflowInstanceReady?: (
+    blockId: string,
+    childWorkflowInstanceId: string,
+    iterationContext?: IterationContext
+  ) => void
+
   /**
    * AbortSignal for cancellation support.
    * When the signal is aborted, execution should stop gracefully.
@@ -361,6 +368,8 @@ export interface BlockHandler {
       parallelId?: string
       branchIndex?: number
       branchTotal?: number
+      originalBlockId?: string
+      isLoopNode?: boolean
     }
   ) => Promise<BlockOutput | StreamingExecution>
 }
diff --git a/apps/sim/hooks/use-execution-stream.ts b/apps/sim/hooks/use-execution-stream.ts
@@ -1,6 +1,7 @@
 import { useCallback } from 'react'
 import { createLogger } from '@sim/logger'
 import type {
+  BlockChildWorkflowStartedData,
   BlockCompletedData,
   BlockErrorData,
   BlockStartedData,
@@ -83,6 +84,9 @@ async function processSSEStream(
             case 'block:error':
               callbacks.onBlockError?.(event.data)
               break
+            case 'block:childWorkflowStarted':
+              callbacks.onBlockChildWorkflowStarted?.(event.data)
+              break
             case 'stream:chunk':
               callbacks.onStreamChunk?.(event.data)
               break
@@ -110,6 +114,7 @@ export interface ExecutionStreamCallbacks {
   onBlockStarted?: (data: BlockStartedData) => void
   onBlockCompleted?: (data: BlockCompletedData) => void
   onBlockError?: (data: BlockErrorData) => void
+  onBlockChildWorkflowStarted?: (data: BlockChildWorkflowStartedData) => void
   onStreamChunk?: (data: StreamChunkData) => void
   onStreamDone?: (data: StreamDoneData) => void
 }
diff --git a/apps/sim/lib/workflows/executor/execution-core.ts b/apps/sim/lib/workflows/executor/execution-core.ts
@@ -129,7 +129,7 @@ export async function executeWorkflowCore(
   const { metadata, workflow, input, workflowVariables, selectedOutputs } = snapshot
   const { requestId, workflowId, userId, triggerType, executionId, triggerBlockId, useDraftState } =
     metadata
-  const { onBlockStart, onBlockComplete, onStream } = callbacks
+  const { onBlockStart, onBlockComplete, onStream, onChildWorkflowInstanceReady } = callbacks
 
   const providedWorkspaceId = metadata.workspaceId
   if (!providedWorkspaceId) {
@@ -329,6 +329,7 @@ export async function executeWorkflowCore(
       includeFileBase64,
       base64MaxBytes,
       stopAfterBlockId: resolvedStopAfterBlockId,
+      onChildWorkflowInstanceReady,
     }
 
     const executorInstance = new Executor({
diff --git a/apps/sim/lib/workflows/executor/execution-events.ts b/apps/sim/lib/workflows/executor/execution-events.ts
