veryfront 0.1.700 → 0.1.703

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

@@ -0,0 +1,134 @@
+import { parseDuration } from "../../types.js";
+import { sleep } from "./utils.js";
+export async function executeLoopNodeStrategy(input) {
+    const { node, config, context, nodeStates, runtime } = input;
+    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 runtime.executeChildGraph(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(),
+    };
+    runtime.onNodeComplete?.(node.id, state);
+    return {
+        state,
+        contextUpdates: {
+            [node.id]: output,
+            ...completionUpdates,
+        },
+        waiting: false,
+    };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"map-node-strategy.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/map-node-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,eAAe,EAEf,YAAY,EAEb,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,UAAU,2BAA2B;IACnC,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACtC,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAqCD,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,mBAAmB,CAAC,CAgE9B"}

package/esm/src/workflow/executor/dag/map-node-strategy.js

@@ -0,0 +1,78 @@
+import { INVALID_ARGUMENT } from "../../../errors/index.js";
+import { deriveNodeStatus } from "./utils.js";
+function isWorkflowDefinition(processor) {
+    return typeof processor === "object" && processor !== null && "steps" in processor;
+}
+function createMapChildNodes(node, config, items) {
+    return items.map((item, i) => {
+        const childId = `${node.id}_${i}`;
+        if (isWorkflowDefinition(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 };
+    });
+}
+export async function executeMapNodeStrategy(input) {
+    const { node, config, context, nodeStates, runtime } = input;
+    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 childNodes = createMapChildNodes(node, config, items);
+    const result = await runtime.executeChildGraph(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(),
+    }, config.concurrency ? { maxConcurrency: config.concurrency } : undefined);
+    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,
+    };
+    runtime.onNodeComplete?.(node.id, state);
+    return {
+        state,
+        contextUpdates: result.completed ? { [node.id]: outputs } : {},
+        waiting: result.waiting,
+    };
+}

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

@@ -0,0 +1,11 @@
+import type { NodeState, WorkflowNode, WorkflowRun } from "../../types.js";
+import type { DAGExecutionResult } from "./types.js";
+export interface ChildGraphExecutionOptions {
+    maxConcurrency?: number;
+}
+export type ExecuteChildGraph = (nodes: WorkflowNode[], run: WorkflowRun, options?: ChildGraphExecutionOptions) => Promise<DAGExecutionResult>;
+export interface NodeStrategyRuntime {
+    executeChildGraph: ExecuteChildGraph;
+    onNodeComplete?: (nodeId: string, state: NodeState) => void;
+}
+//# sourceMappingURL=node-strategy-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node-strategy-types.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/node-strategy-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,MAAM,WAAW,0BAA0B;IACzC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,iBAAiB,GAAG,CAC9B,KAAK,EAAE,YAAY,EAAE,EACrB,GAAG,EAAE,WAAW,EAChB,OAAO,CAAC,EAAE,0BAA0B,KACjC,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAEjC,MAAM,WAAW,mBAAmB;IAClC,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;CAC7D"}

package/esm/src/workflow/executor/dag/node-strategy-types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.700",
+  "version": "0.1.703",
   "description": "The simplest way to build AI-powered apps",
   "keywords": [
     "react",