veryfront 0.1.700 → 0.1.703

package/esm/src/workflow/claude-code/react/use-claude-code-stream.js

@@ -5,6 +5,7 @@
  */
 import * as dntShim from "../../../../_dnt.shims.js";
 import { useCallback, useEffect, useRef, useState } from "../../../../react/react.js";
+import { createClaudeCodeEventState, reduceClaudeCodeEventState, } from "./event-state-reducer.js";
 import { REQUEST_ERROR } from "../../../errors/index.js";
 /** Default delay before reconnecting after disconnect */
 const DEFAULT_RECONNECT_DELAY_MS = 1_000;
@@ -48,16 +49,9 @@ const DEFAULT_MAX_EVENT_HISTORY = 100;
 export function useClaudeCodeStream(options) {
     const { url, runId, autoConnect = true, autoReconnect = true, maxReconnectAttempts = 5, reconnectDelay = DEFAULT_RECONNECT_DELAY_MS, keepEventHistory = false, maxEventHistory = DEFAULT_MAX_EVENT_HISTORY, onEvent, onConnect, onDisconnect, onError, onComplete, } = options;
     const [state, setState] = useState({
+        ...createClaudeCodeEventState(),
         isConnected: false,
-        isRunning: false,
-        currentIteration: 0,
-        maxIterations: 20,
-        text: "",
-        currentTool: null,
-        toolCalls: [],
         allToolCalls: [],
-        result: null,
-        error: null,
         events: [],
     });
     const eventSourceRef = useRef(null);
@@ -67,76 +61,13 @@ export function useClaudeCodeStream(options) {
     const processEvent = useCallback((event) => {
         onEvent?.(event);
         setState((prev) => {
-            const newState = { ...prev };
-            // Keep event history if enabled
-            if (keepEventHistory) {
-                newState.events = [...prev.events, event].slice(-maxEventHistory);
-            }
-            switch (event.type) {
-                case "iteration_start":
-                    newState.isRunning = true;
-                    newState.currentIteration = event.iteration;
-                    newState.maxIterations = event.maxIterations;
-                    newState.toolCalls = [];
-                    newState.currentTool = null;
-                    break;
-                case "text_delta":
-                    newState.text = prev.text + event.content;
-                    break;
-                case "text_complete":
-                    newState.text = event.content;
-                    break;
-                case "tool_call_start":
-                    newState.currentTool = {
-                        id: event.toolCallId,
-                        name: event.toolName,
-                        input: {},
-                    };
-                    break;
-                case "tool_call_complete":
-                    newState.currentTool = null;
-                    newState.toolCalls = [
-                        ...prev.toolCalls,
-                        {
-                            id: event.toolCallId,
-                            name: event.toolName,
-                            input: event.input,
-                        },
-                    ];
-                    break;
-                case "tool_result":
-                    // Update the tool call with its result
-                    newState.toolCalls = prev.toolCalls.map((tc) => tc.id === event.toolCallId
-                        ? { ...tc, output: event.output, isError: event.isError }
-                        : tc);
-                    // Add to all tool calls
-                    newState.allToolCalls = [
-                        ...prev.allToolCalls,
-                        {
-                            iteration: event.iteration || prev.currentIteration,
-                            id: event.toolCallId,
-                            name: event.toolName,
-                            input: prev.toolCalls.find((tc) => tc.id === event.toolCallId)?.input || {},
-                            output: event.output,
-                            isError: event.isError,
-                        },
-                    ];
-                    break;
-                case "iteration_complete":
-                    newState.currentTool = null;
-                    break;
-                case "complete":
-                    newState.isRunning = false;
-                    newState.result = event.result;
-                    newState.currentTool = null;
-                    onComplete?.(event.result);
-                    break;
-                case "error":
-                    newState.error = event.message;
-                    if (!event.recoverable) {
-                        newState.isRunning = false;
-                    }
-                    break;
+            const newState = reduceClaudeCodeEventState(prev, event, {
+                keepEventHistory,
+                maxEventHistory,
+                trackAllToolCalls: true,
+            });
+            if (event.type === "complete") {
+                onComplete?.(event.result);
             }
             return newState;
         });

package/esm/src/workflow/claude-code/react/use-claude-code-websocket.d.ts

@@ -1,4 +1,5 @@
 import type { ClaudeCodeEventExtended, ClaudeCodeResult } from "../types.js";
+import { type ClaudeCodeEventState } from "./event-state-reducer.js";
 /**
  * Pending approval state
  */
@@ -22,41 +23,15 @@ export interface PendingInput {
 /**
  * State for Claude Code WebSocket
  */
-export interface UseClaudeCodeWebSocketState {
+export interface UseClaudeCodeWebSocketState extends ClaudeCodeEventState {
     /** Whether currently connected */
     isConnected: boolean;
-    /** Whether agent is currently executing */
-    isRunning: boolean;
     /** Whether agent was cancelled */
     isCancelled: boolean;
-    /** Current iteration number */
-    currentIteration: number;
-    /** Maximum iterations allowed */
-    maxIterations: number;
-    /** Accumulated text output */
-    text: string;
-    /** Current tool being executed (if any) */
-    currentTool: {
-        id: string;
-        name: string;
-        input: Record<string, unknown>;
-    } | null;
-    /** Tool calls in current iteration */
-    toolCalls: Array<{
-        id: string;
-        name: string;
-        input: Record<string, unknown>;
-        output?: string;
-        isError?: boolean;
-    }>;
     /** Pending approval requests */
     pendingApprovals: PendingApproval[];
     /** Pending input request (if any) */
     pendingInput: PendingInput | null;
-    /** Final result (when complete) */
-    result: ClaudeCodeResult | null;
-    /** Error message (if any) */
-    error: string | null;
 }
 /**
  * Options for useClaudeCodeWebSocket hook

package/esm/src/workflow/claude-code/react/use-claude-code-websocket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-claude-code-websocket.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/claude-code/react/use-claude-code-websocket.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"use-claude-code-websocket.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/claude-code/react/use-claude-code-websocket.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAGV,uBAAuB,EACvB,gBAAgB,EAEjB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,oBAAoB,EAI1B,MAAM,0BAA0B,CAAC;AASlC;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,oBAAoB;IACvE,kCAAkC;IAClC,WAAW,EAAE,OAAO,CAAC;IAErB,kCAAkC;IAClC,WAAW,EAAE,OAAO,CAAC;IAErB,gCAAgC;IAChC,gBAAgB,EAAE,eAAe,EAAE,CAAC;IAEpC,qCAAqC;IACrC,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAC;IAEZ,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IAEd,4BAA4B;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,8BAA8B;IAC9B,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB,6BAA6B;IAC7B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B,2BAA2B;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,yBAAyB;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,gBAAgB;IAChB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,CAAC;IACnD,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAChD,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,CAAC;IACxD,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;CAChD;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C,2BAA2B;IAC3B,OAAO,EAAE,MAAM,IAAI,CAAC;IAEpB,gCAAgC;IAChC,UAAU,EAAE,MAAM,IAAI,CAAC;IAEvB,iCAAiC;IACjC,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAElC,kCAAkC;IAClC,OAAO,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IAEtC,iCAAiC;IACjC,MAAM,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAEtD,sBAAsB;IACtB,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,6BAA6B,GACrC,2BAA2B,GAAG,6BAA6B,CAkR7D"}

package/esm/src/workflow/claude-code/react/use-claude-code-websocket.js

@@ -5,6 +5,7 @@
  */
 import * as dntShim from "../../../../_dnt.shims.js";
 import { useCallback, useEffect, useRef, useState } from "../../../../react/react.js";
+import { createClaudeCodeEventState, isClaudeCodeCoreEvent, reduceClaudeCodeEventState, } from "./event-state-reducer.js";
 import { NETWORK_ERROR, REQUEST_ERROR } from "../../../errors/index.js";
 /** Default delay before reconnecting after disconnect */
 const DEFAULT_RECONNECT_DELAY_MS = 1_000;
@@ -52,18 +53,11 @@ const DEFAULT_PING_INTERVAL_MS = 30_000;
 export function useClaudeCodeWebSocket(options) {
     const { url, runId, autoConnect = true, autoReconnect = true, maxReconnectAttempts = 5, reconnectDelay = DEFAULT_RECONNECT_DELAY_MS, pingInterval = DEFAULT_PING_INTERVAL_MS, onEvent, onConnect, onDisconnect, onError, onComplete, onApprovalRequest, onInputRequest, } = options;
     const [state, setState] = useState({
+        ...createClaudeCodeEventState(),
         isConnected: false,
-        isRunning: false,
         isCancelled: false,
-        currentIteration: 0,
-        maxIterations: 20,
-        text: "",
-        currentTool: null,
-        toolCalls: [],
         pendingApprovals: [],
         pendingInput: null,
-        result: null,
-        error: null,
     });
     const socketRef = useRef(null);
     const reconnectAttemptsRef = useRef(0);
@@ -73,61 +67,15 @@ export function useClaudeCodeWebSocket(options) {
     const processEvent = useCallback((event) => {
         onEvent?.(event);
         setState((prev) => {
-            const newState = { ...prev };
+            const newState = isClaudeCodeCoreEvent(event)
+                ? reduceClaudeCodeEventState(prev, event)
+                : { ...prev };
             switch (event.type) {
-                case "iteration_start":
-                    newState.isRunning = true;
-                    newState.currentIteration = event.iteration;
-                    newState.maxIterations = event.maxIterations;
-                    newState.toolCalls = [];
-                    newState.currentTool = null;
-                    break;
-                case "text_delta":
-                    newState.text = prev.text + event.content;
-                    break;
-                case "text_complete":
-                    newState.text = event.content;
-                    break;
-                case "tool_call_start":
-                    newState.currentTool = {
-                        id: event.toolCallId,
-                        name: event.toolName,
-                        input: {},
-                    };
-                    break;
-                case "tool_call_complete":
-                    newState.currentTool = null;
-                    newState.toolCalls = [
-                        ...prev.toolCalls,
-                        {
-                            id: event.toolCallId,
-                            name: event.toolName,
-                            input: event.input,
-                        },
-                    ];
-                    break;
-                case "tool_result":
-                    newState.toolCalls = prev.toolCalls.map((tc) => tc.id === event.toolCallId
-                        ? { ...tc, output: event.output, isError: event.isError }
-                        : tc);
-                    break;
-                case "iteration_complete":
-                    newState.currentTool = null;
-                    break;
                 case "complete":
-                    newState.isRunning = false;
-                    newState.result = event.result;
-                    newState.currentTool = null;
                     newState.pendingApprovals = [];
                     newState.pendingInput = null;
                     onComplete?.(event.result);
                     break;
-                case "error":
-                    newState.error = event.message;
-                    if (!event.recoverable) {
-                        newState.isRunning = false;
-                    }
-                    break;
                 case "cancelled":
                     newState.isRunning = false;
                     newState.isCancelled = true;

package/esm/src/workflow/executor/dag/index.d.ts

@@ -15,11 +15,10 @@ export declare class DAGExecutor {
     private executeNode;
     private executeStepNode;
     private executeParallelNode;
-    private executeMapNode;
     private executeBranchNode;
     private executeWaitNode;
     private executeSubWorkflowNode;
-    private executeLoopNode;
     private checkpoint;
+    private executeChildGraph;
 }
 //# sourceMappingURL=index.d.ts.map

package/esm/src/workflow/executor/dag/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAYV,YAAY,EAEZ,WAAW,EACZ,MAAM,gBAAgB,CAAC;AAIxB,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAE7F,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AAIpB,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAA4B;gBAE9B,MAAM,EAAE,iBAAiB;IAQ/B,OAAO,CACX,KAAK,EAAE,YAAY,EAAE,EACrB,GAAG,EAAE,WAAW,EAChB,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,kBAAkB,CAAC;YAsGhB,WAAW;YA8CX,eAAe;YA0Bf,mBAAmB;YA4CnB,cAAc;YAqGd,iBAAiB;YA+DjB,eAAe;YA8Bf,sBAAsB;YA+DtB,eAAe;YAsKf,UAAU;CAoBzB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAQV,YAAY,EAEZ,WAAW,EACZ,MAAM,gBAAgB,CAAC;AAIxB,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAE7F,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AAOpB,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAA4B;gBAE9B,MAAM,EAAE,iBAAiB;IAQ/B,OAAO,CACX,KAAK,EAAE,YAAY,EAAE,EACrB,GAAG,EAAE,WAAW,EAChB,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,kBAAkB,CAAC;YAsGhB,WAAW;YAgEX,eAAe;YA0Bf,mBAAmB;YA4CnB,iBAAiB;YA+DjB,eAAe;YA8Bf,sBAAsB;YA+DtB,UAAU;YAqBV,iBAAiB;CAiBhC"}

package/esm/src/workflow/executor/dag/index.js

@@ -5,10 +5,12 @@
  *
  * @module ai/workflow/executor/dag
  */
-import { generateId, parseDuration } from "../../types.js";
+import { generateId } from "../../types.js";
 import { INVALID_ARGUMENT, NOT_SUPPORTED } from "../../../errors/index.js";
-import { deriveNodeStatus, shouldCheckpoint, sleep } from "./utils.js";
+import { deriveNodeStatus, shouldCheckpoint } from "./utils.js";
 import { buildGraph, getReadyNodes, hasCycle, updateInDegreesForCompletedNodes } from "./graph.js";
+import { executeLoopNodeStrategy } from "./loop-node-strategy.js";
+import { executeMapNodeStrategy } from "./map-node-strategy.js";
 export class DAGExecutor {
     config;
     constructor(config) {
@@ -118,7 +120,16 @@ export class DAGExecutor {
             case "parallel":
                 return this.executeParallelNode(node, config, context, nodeStates);
             case "map":
-                return this.executeMapNode(node, config, context, nodeStates);
+                return executeMapNodeStrategy({
+                    node,
+                    config,
+                    context,
+                    nodeStates,
+                    runtime: {
+                        executeChildGraph: (nodes, run, options) => this.executeChildGraph(nodes, run, options),
+                        onNodeComplete: this.config.onNodeComplete,
+                    },
+                });
             case "branch":
                 return this.executeBranchNode(node, config, context, nodeStates);
             case "wait":
@@ -126,7 +137,16 @@ export class DAGExecutor {
             case "subWorkflow":
                 return this.executeSubWorkflowNode(node, config, context);
             case "loop":
-                return this.executeLoopNode(node, config, context, nodeStates);
+                return executeLoopNodeStrategy({
+                    node,
+                    config,
+                    context,
+                    nodeStates,
+                    runtime: {
+                        executeChildGraph: (nodes, run) => this.executeChildGraph(nodes, run),
+                        onNodeComplete: this.config.onNodeComplete,
+                    },
+                });
             default:
                 throw INVALID_ARGUMENT.create({
                     detail: `Unknown node type "${config.type}" for node "${node.id}". ` +
@@ -186,85 +206,6 @@ export class DAGExecutor {
             waiting: result.waiting,
         };
     }
-    async executeMapNode(node, config, context, nodeStates) {
-        const startTime = Date.now();
-        const items = typeof config.items === "function" ? await config.items(context) : config.items;
-        if (!Array.isArray(items)) {
-            throw INVALID_ARGUMENT.create({ detail: `Map node "${node.id}" items must be an array` });
-        }
-        if (items.length === 0) {
-            const state = {
-                nodeId: node.id,
-                status: "completed",
-                output: [],
-                attempt: 1,
-                startedAt: new Date(startTime),
-                completedAt: new Date(),
-            };
-            return { state, contextUpdates: { [node.id]: [] }, waiting: false };
-        }
-        const isWorkflowDef = (p) => typeof p === "object" && p !== null && "steps" in p;
-        const childNodes = items.map((item, i) => {
-            const childId = `${node.id}_${i}`;
-            if (isWorkflowDef(config.processor)) {
-                return {
-                    id: childId,
-                    config: {
-                        type: "subWorkflow",
-                        workflow: config.processor,
-                        input: item,
-                        retry: config.retry,
-                        checkpoint: false,
-                    },
-                };
-            }
-            const processorConfig = { ...config.processor.config };
-            if (processorConfig.type === "step") {
-                processorConfig.input = item;
-            }
-            return { id: childId, config: processorConfig };
-        });
-        const originalConcurrency = this.config.maxConcurrency;
-        if (config.concurrency) {
-            this.config.maxConcurrency = config.concurrency;
-        }
-        try {
-            const result = await this.execute(childNodes, {
-                id: `${node.id}_map`,
-                workflowId: "",
-                status: "running",
-                input: context.input,
-                // Carry already-accumulated child states so completed children are
-                // skipped on resume instead of re-executing (H8).
-                nodeStates,
-                currentNodes: [],
-                context: { ...context },
-                checkpoints: [],
-                pendingApprovals: [],
-                createdAt: new Date(),
-            });
-            Object.assign(nodeStates, result.nodeStates);
-            const outputs = childNodes.map((child) => result.nodeStates[child.id]?.output);
-            const state = {
-                nodeId: node.id,
-                status: deriveNodeStatus(result.completed, result.waiting),
-                output: outputs,
-                error: result.error,
-                attempt: 1,
-                startedAt: new Date(startTime),
-                completedAt: result.completed ? new Date() : undefined,
-            };
-            this.config.onNodeComplete?.(node.id, state);
-            return {
-                state,
-                contextUpdates: result.completed ? { [node.id]: outputs } : {},
-                waiting: result.waiting,
-            };
-        }
-        finally {
-            this.config.maxConcurrency = originalConcurrency;
-        }
-    }
     async executeBranchNode(node, config, context, nodeStates) {
         const startTime = Date.now();
         const conditionResult = await config.condition(context);
@@ -383,139 +324,6 @@ export class DAGExecutor {
             waiting: result.waiting,
         };
     }
-    async executeLoopNode(node, config, context, nodeStates) {
-        const startTime = Date.now();
-        const previousResults = [];
-        let iteration = 0;
-        let exitReason = "condition";
-        let lastError;
-        const existingLoopState = context[`${node.id}_loop_state`];
-        // Child node states for the in-flight (resumed) iteration, so its already
-        // completed steps are not re-executed on resume (H9).
-        let resumeIterationNodeStates;
-        let resumeIteration;
-        if (existingLoopState) {
-            iteration = existingLoopState.iteration;
-            previousResults.push(...existingLoopState.previousResults);
-            resumeIterationNodeStates = existingLoopState.iterationNodeStates;
-            resumeIteration = existingLoopState.iteration;
-        }
-        while (iteration < config.maxIterations) {
-            const loopContext = {
-                iteration,
-                totalIterations: iteration,
-                previousResults: [...previousResults],
-                isFirstIteration: iteration === 0,
-                isLastAllowedIteration: iteration === config.maxIterations - 1,
-            };
-            if (!(await config.while(context, loopContext))) {
-                exitReason = "condition";
-                break;
-            }
-            const steps = typeof config.steps === "function"
-                ? config.steps(context, loopContext)
-                : config.steps;
-            // On resume, rehydrate the in-flight iteration's child node states so its
-            // already-completed steps are skipped instead of re-executed (H9).
-            const iterationNodeStates = resumeIteration === iteration && resumeIterationNodeStates
-                ? { ...resumeIterationNodeStates }
-                : {};
-            // Only rehydrate once; subsequent iterations start fresh.
-            resumeIterationNodeStates = undefined;
-            const result = await this.execute(steps, {
-                id: `${node.id}_iter_${iteration}`,
-                workflowId: "",
-                status: "running",
-                input: context.input,
-                nodeStates: iterationNodeStates,
-                currentNodes: [],
-                context: { ...context, _loop: loopContext },
-                checkpoints: [],
-                pendingApprovals: [],
-                createdAt: new Date(),
-            });
-            if (result.waiting) {
-                Object.assign(nodeStates, result.nodeStates);
-                const state = {
-                    nodeId: node.id,
-                    status: "running",
-                    output: { iteration, waiting: true, previousResults },
-                    attempt: 1,
-                    startedAt: new Date(startTime),
-                };
-                return {
-                    state,
-                    contextUpdates: {
-                        ...result.context,
-                        [`${node.id}_loop_state`]: {
-                            iteration,
-                            previousResults,
-                            // Persist the in-flight iteration's child states so completed
-                            // steps are not re-executed when this iteration resumes (H9).
-                            iterationNodeStates: result.nodeStates,
-                        },
-                    },
-                    waiting: true,
-                };
-            }
-            if (result.error) {
-                lastError = result.error;
-                exitReason = "error";
-                break;
-            }
-            previousResults.push(result.context);
-            Object.assign(context, result.context);
-            Object.assign(nodeStates, result.nodeStates);
-            if (config.delay && iteration < config.maxIterations - 1) {
-                const delayMs = typeof config.delay === "number"
-                    ? config.delay
-                    : parseDuration(config.delay);
-                await sleep(delayMs);
-            }
-            iteration++;
-        }
-        if (iteration >= config.maxIterations && exitReason !== "condition") {
-            exitReason = "maxIterations";
-        }
-        const finalLoopContext = {
-            iteration,
-            totalIterations: iteration,
-            previousResults,
-            isFirstIteration: false,
-            isLastAllowedIteration: true,
-        };
-        let completionUpdates = {};
-        if (exitReason === "maxIterations" && config.onMaxIterations) {
-            completionUpdates = await config.onMaxIterations(context, finalLoopContext);
-        }
-        else if (exitReason === "condition" && config.onComplete) {
-            completionUpdates = await config.onComplete(context, finalLoopContext);
-        }
-        const output = {
-            exitReason,
-            iterations: iteration,
-            previousResults,
-            ...completionUpdates,
-        };
-        const state = {
-            nodeId: node.id,
-            status: exitReason === "error" ? "failed" : "completed",
-            output,
-            error: lastError,
-            attempt: 1,
-            startedAt: new Date(startTime),
-            completedAt: new Date(),
-        };
-        this.config.onNodeComplete?.(node.id, state);
-        return {
-            state,
-            contextUpdates: {
-                [node.id]: output,
-                ...completionUpdates,
-            },
-            waiting: false,
-        };
-    }
     async checkpoint(runId, nodeId, context, nodeStates) {
         if (!this.config.checkpointManager) {
             return;
@@ -529,4 +337,17 @@ export class DAGExecutor {
         };
         await this.config.checkpointManager.save(runId, checkpoint);
     }
+    async executeChildGraph(nodes, run, options) {
+        if (!options?.maxConcurrency) {
+            return await this.execute(nodes, run);
+        }
+        const originalConcurrency = this.config.maxConcurrency;
+        this.config.maxConcurrency = options.maxConcurrency;
+        try {
+            return await this.execute(nodes, run);
+        }
+        finally {
+            this.config.maxConcurrency = originalConcurrency;
+        }
+    }
 }

package/esm/src/workflow/executor/dag/loop-node-strategy.d.ts

@@ -0,0 +1,13 @@
+import type { LoopNodeConfig, NodeState, WorkflowContext, WorkflowNode } from "../../types.js";
+import type { NodeExecutionResult } from "./types.js";
+import type { NodeStrategyRuntime } from "./node-strategy-types.js";
+interface ExecuteLoopNodeStrategyInput {
+    node: WorkflowNode;
+    config: LoopNodeConfig;
+    context: WorkflowContext;
+    nodeStates: Record<string, NodeState>;
+    runtime: NodeStrategyRuntime;
+}
+export declare function executeLoopNodeStrategy(input: ExecuteLoopNodeStrategyInput): Promise<NodeExecutionResult>;
+export {};
+//# sourceMappingURL=loop-node-strategy.d.ts.map

package/esm/src/workflow/executor/dag/loop-node-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop-node-strategy.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/loop-node-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EACd,SAAS,EACT,eAAe,EACf,YAAY,EACb,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,UAAU,4BAA4B;IACpC,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACtC,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAQD,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,mBAAmB,CAAC,CAwJ9B"}