@acpus/runtime 0.6.1 → 0.6.3

package/dist/interpreter.js

@@ -247,9 +247,10 @@ export class WorkflowInterpreter {
                 }
                 break;
             case "parallel":
-                (node.children ?? []).forEach((child, index) => {
-                    const branchDynamic = nestedParallelBranchDynamic(dynamic, index);
-                    this.replayNode(child, ctx, runId, branchDynamic, keyPrefix, recorded, reached, evaluator);
+                (node.branches ?? []).forEach((branch) => {
+                    const branchDynamic = nestedParallelBranchDynamic(dynamic, branch.id);
+                    const branchCtx = { ...ctx, steps: { ...ctx.steps } };
+                    this.replayNode(branch.child, branchCtx, runId, branchDynamic, keyPrefix, recorded, reached, evaluator);
                 });
                 break;
             case "fanout": {
@@ -258,7 +259,7 @@ export class WorkflowInterpreter {
                 items.forEach((item, index) => {
                     const keyCtx = { ...ctx, item, item_index: index };
                     const itemId = this.extractItemId(item, node.metadata.key, index, keyCtx, evaluator);
-                    const itemDynamic = { ...dynamic, fanoutItemId: itemId, laneId: String(index) };
+                    const itemDynamic = appendDynamicFrame(dynamic, { fanoutItemId: itemId, laneId: String(index) });
                     const itemCtx = { ...keyCtx, steps: { ...ctx.steps }, item_id: itemId };
                     for (const child of node.children ?? []) {
                         this.replayNode(child, itemCtx, runId, itemDynamic, keyPrefix, recorded, reached, evaluator);
@@ -270,9 +271,7 @@ export class WorkflowInterpreter {
                 for (const branch of node.branches ?? []) {
                     const taken = !branch.when || Boolean(evaluator.evaluateExpression(branch.when, ctx));
                     if (taken) {
-                        for (const child of branch.children) {
-                            this.replayNode(child, ctx, runId, dynamic, keyPrefix, recorded, reached, evaluator);
-                        }
+                        this.replayNode(branch.child, ctx, runId, dynamic, keyPrefix, recorded, reached, evaluator);
                         break;
                     }
                 }
@@ -283,7 +282,7 @@ export class WorkflowInterpreter {
                 let lastOutput;
                 for (let iter = 0; iter < maxIterations; iter++) {
                     const loopCtx = { ...ctx, loop: { iter, last: lastOutput } };
-                    const loopDynamic = { ...dynamic, loopRound: iter };
+                    const loopDynamic = appendDynamicFrame(dynamic, { loopRound: iter });
                     if (untilExpr && iter > 0 && evaluator.evaluateExpression(untilExpr, loopCtx))
                         break;
                     // Only descend while this round's children were actually recorded.
@@ -294,7 +293,8 @@ export class WorkflowInterpreter {
                         if (reached.size > before)
                             anyChildReached = true;
                         const childKey = withNodeKeyPrefix(keyPrefix, resolveNodeKey(child.keyTemplate, loopDynamic));
-                        lastOutput = recorded.get(childKey)?.output ?? lastOutput;
+                        const recordedOutput = recorded.get(childKey)?.output;
+                        lastOutput = recordedOutput !== undefined ? primaryOutput(recordedOutput) : lastOutput;
                     }
                     if (!anyChildReached)
                         break;
@@ -335,13 +335,14 @@ export class WorkflowInterpreter {
         // transition. `attempt` is incremented by executeNode.
         this.runControl.resetNodeForRetry(runId, state);
         const ctx = this.buildContext(ir, input, runId);
-        this.populateStepOutputs(runId, ctx);
+        const retryTarget = this.hydrateContextForNodeRetry(ir.root, ctx, runId, nodeKey, {});
         // Restore the parent dynamic value-context captured at first execution.
-        this.restoreDynamicContext(ctx, state.dynamicContext);
+        const retryCtx = retryTarget?.ctx ?? ctx;
+        this.restoreDynamicContext(retryCtx, state.dynamicContext);
         // Retry re-runs the executable as a continuation: agents keep the same acpx
         // session name and receive the fixed continuation prompt. The original full
         // node key is preserved for stable identity.
-        await this.executeNode(node, ctx, runId, {}, undefined, true, nodeKey);
+        await this.executeNode(node, retryCtx, runId, retryTarget?.dynamic ?? {}, undefined, true, nodeKey);
     }
     // ─── Run-level controls ─────────────────────────────────────────
     /**
@@ -565,18 +566,35 @@ export class WorkflowInterpreter {
     // ─── Kind-specific execution ───────────────────────────────────
     async executePipeline(node, ctx, runId, dynamic, keyPrefix) {
         const children = node.children ?? [];
+        if (node.metadata.implicit === true) {
+            for (const child of children) {
+                try {
+                    await this.executeNode(child, ctx, runId, dynamic, keyPrefix);
+                }
+                catch (error) {
+                    if (error instanceof ScopeCompleted)
+                        return { output: { ...ctx.steps } };
+                    throw error;
+                }
+            }
+            return { output: { ...ctx.steps } };
+        }
+        const frame = { ...ctx, steps: { ...ctx.steps } };
+        let lastOutput;
         for (const child of children) {
             try {
-                await this.executeNode(child, ctx, runId, dynamic, keyPrefix);
+                lastOutput = await this.executeNode(child, frame, runId, dynamic, keyPrefix);
             }
             catch (error) {
                 if (error instanceof ScopeCompleted)
-                    return { output: error.output };
+                    return { output: primaryOutput(error.output) };
                 throw error;
             }
         }
-        // Pipeline output: map of step outputs
-        return { output: { ...ctx.steps } };
+        if (isRecord(node.metadata.outputs)) {
+            return { output: evaluateWorkflowOutputs({ outputs: node.metadata.outputs }, frame, this.evaluator) };
+        }
+        return { output: primaryOutput(lastOutput) };
     }
     async executeAgent(node, ctx, runId, signal, nodeKey, continuation) {
         const retry = node.metadata.retry;
@@ -809,21 +827,20 @@ export class WorkflowInterpreter {
         state.renderedPrompt = persisted?.renderedPrompt ?? state.renderedPrompt;
     }
     async executeParallel(node, ctx, runId, dynamic, nodeKey, keyPrefix) {
-        const children = node.children ?? [];
+        const branches = node.branches ?? [];
         const maxConcurrency = node.metadata.max_concurrency ?? this.maxConcurrency;
         const join = node.metadata.join ?? "all";
         if (join === "all") {
-            children.forEach((child, index) => {
-                this.materializePendingNode(runId, child, ctx, nestedParallelBranchDynamic(dynamic, index), keyPrefix);
+            branches.forEach((branch) => {
+                this.materializePendingNode(runId, branch.child, ctx, nestedParallelBranchDynamic(dynamic, branch.id), keyPrefix);
             });
         }
         const limit = pLimit(maxConcurrency);
-        // Each branch resolves to { child, output } so race can identify the winner.
-        const branchPromises = children.map((child, index) => limit(async () => {
-            const branchDynamic = nestedParallelBranchDynamic(dynamic, index);
+        const branchPromises = branches.map((branch) => limit(async () => {
+            const branchDynamic = nestedParallelBranchDynamic(dynamic, branch.id);
             let output;
             try {
-                output = await this.executeNode(child, { ...ctx, steps: { ...ctx.steps } }, runId, branchDynamic, keyPrefix);
+                output = await this.executeNode(branch.child, { ...ctx, steps: { ...ctx.steps } }, runId, branchDynamic, keyPrefix);
             }
             catch (error) {
                 if (error instanceof ScopeCompleted) {
@@ -833,7 +850,7 @@ export class WorkflowInterpreter {
                     throw error;
                 }
             }
-            return { child, output };
+            return { branch, output };
         }));
         if (join === "race") {
             try {
@@ -841,8 +858,7 @@ export class WorkflowInterpreter {
                 // consumed so their later rejection doesn't surface as unhandled.
                 const winner = await Promise.race(branchPromises);
                 branchPromises.forEach((p) => void p.catch(() => undefined));
-                const mapOutput = { [winner.child.id]: winner.output };
-                ctx.steps[winner.child.id] = winner.output;
+                const mapOutput = { [winner.branch.id]: primaryOutput(winner.output) };
                 return { output: mapOutput };
             }
             catch (error) {
@@ -871,9 +887,8 @@ export class WorkflowInterpreter {
             throw error;
         }
         const mapOutput = {};
-        for (const { child, output } of results) {
-            mapOutput[child.id] = output;
-            ctx.steps[child.id] = output;
+        for (const { branch, output } of results) {
+            mapOutput[branch.id] = primaryOutput(output);
         }
         return { output: mapOutput };
     }
@@ -887,7 +902,10 @@ export class WorkflowInterpreter {
         const join = node.metadata.join ?? "all";
         const quorum = node.metadata.quorum;
         const successCriteria = node.metadata.success_criteria;
-        const children = node.children ?? [];
+        const body = node.children?.[0];
+        if (!body) {
+            throw new Error(`fanout node ${node.id} missing body pipeline`);
+        }
         const limit = pLimit(maxConcurrency);
         // Success target (how many lanes must succeed). Default follows join.
         const defaultMinSuccess = join === "race" ? 1 : join === "quorum" ? (quorum ?? 1) : items.length;
@@ -895,7 +913,7 @@ export class WorkflowInterpreter {
         const lanePlan = items.map((item, index) => {
             const keyCtx = { ...ctx, item, item_index: index };
             const itemId = this.extractItemId(item, node.metadata.key, index, keyCtx, this.evaluator);
-            const laneDynamic = { fanoutItemId: itemId, laneId: String(index) };
+            const laneDynamic = appendDynamicFrame({}, { fanoutItemId: itemId, laneId: String(index) });
             return {
                 itemId,
                 keyCtx,
@@ -904,10 +922,8 @@ export class WorkflowInterpreter {
         });
         if (join === "all") {
             for (const lane of lanePlan) {
-                const itemDynamic = { ...dynamic, ...lane.itemDynamic };
-                for (const child of children) {
-                    this.materializePendingNode(runId, child, lane.keyCtx, itemDynamic, keyPrefix);
-                }
+                const itemDynamic = appendDynamicFrames(dynamic, lane.itemDynamic);
+                this.materializePendingNode(runId, body, lane.keyCtx, itemDynamic, keyPrefix);
             }
         }
         // Fail-fast: once enough lanes have failed that the success target is
@@ -922,27 +938,19 @@ export class WorkflowInterpreter {
         // not reject) so the join/min_success logic can run. A NodeAbortedError
         // (operator pause/cancel) re-throws so it propagates to the parent.
         const lanePromises = lanePlan.map((lane) => limit(async () => {
-            const itemDynamic = { ...dynamic, ...lane.itemDynamic };
+            const itemDynamic = appendDynamicFrames(dynamic, lane.itemDynamic);
             const itemCtx = {
                 ...lane.keyCtx,
                 steps: { ...ctx.steps },
                 item_id: lane.itemId
             };
             try {
-                let laneOutput;
-                for (const child of children) {
-                    try {
-                        laneOutput = await this.executeNode(child, itemCtx, runId, itemDynamic, keyPrefix);
-                    }
-                    catch (error) {
-                        if (error instanceof ScopeCompleted)
-                            return { ok: true, output: error.output };
-                        throw error;
-                    }
-                }
-                return { ok: true, output: laneOutput };
+                const laneOutput = await this.executeNode(body, itemCtx, runId, itemDynamic, keyPrefix);
+                return { ok: true, output: primaryOutput(laneOutput) };
             }
             catch (error) {
+                if (error instanceof ScopeCompleted)
+                    return { ok: true, output: primaryOutput(error.output) };
                 if (error instanceof NodeAbortedError) {
                     throw error;
                 }
@@ -1008,37 +1016,16 @@ export class WorkflowInterpreter {
     async executeSwitch(node, ctx, runId, dynamic, keyPrefix) {
         const branches = node.branches ?? [];
         for (const branch of branches) {
-            if (branch.when) {
-                const matches = this.evaluator.evaluateExpression(branch.when, ctx);
-                if (matches) {
-                    let lastOutput;
-                    for (const child of branch.children) {
-                        try {
-                            lastOutput = await this.executeNode(child, ctx, runId, dynamic, keyPrefix);
-                        }
-                        catch (error) {
-                            if (error instanceof ScopeCompleted)
-                                return { output: error.output };
-                            throw error;
-                        }
-                    }
-                    return { output: lastOutput };
-                }
+            if (branch.when && !this.evaluator.evaluateExpression(branch.when, ctx))
+                continue;
+            // Default branch has no condition and is reached only after earlier cases fail.
+            try {
+                return { output: primaryOutput(await this.executeNode(branch.child, ctx, runId, dynamic, keyPrefix)) };
             }
-            else {
-                // Default branch (no when condition)
-                let lastOutput;
-                for (const child of branch.children) {
-                    try {
-                        lastOutput = await this.executeNode(child, ctx, runId, dynamic, keyPrefix);
-                    }
-                    catch (error) {
-                        if (error instanceof ScopeCompleted)
-                            return { output: error.output };
-                        throw error;
-                    }
-                }
-                return { output: lastOutput };
+            catch (error) {
+                if (error instanceof ScopeCompleted)
+                    return { output: primaryOutput(error.output) };
+                throw error;
             }
         }
         throw new Error(`Switch node ${node.id}: no branch matched and no default`);
@@ -1046,35 +1033,33 @@ export class WorkflowInterpreter {
     async executeLoop(node, ctx, runId, dynamic, keyPrefix) {
         const untilExpr = node.metadata.until;
         const maxIterations = node.metadata.max_iterations ?? 100;
-        const children = node.children ?? [];
+        const body = node.children?.[0];
+        if (!body) {
+            throw new Error(`loop node ${node.id} missing body pipeline`);
+        }
         let lastOutput;
         for (let iter = 0; iter < maxIterations; iter++) {
             const loopCtx = {
                 ...ctx,
                 loop: { iter, last: lastOutput }
             };
-            const loopDynamic = { ...dynamic, loopRound: iter };
+            const loopDynamic = appendDynamicFrame(dynamic, { loopRound: iter });
             // Check until condition (skip on first iteration)
             if (untilExpr && iter > 0) {
                 const done = this.evaluator.evaluateExpression(untilExpr, loopCtx);
                 if (done)
                     break;
             }
-            // Execute loop body
-            for (const child of children) {
-                try {
-                    lastOutput = await this.executeNode(child, loopCtx, runId, loopDynamic, keyPrefix);
-                }
-                catch (error) {
-                    if (error instanceof ScopeCompleted)
-                        return { output: error.output };
-                    throw error;
-                }
+            try {
+                lastOutput = primaryOutput(await this.executeNode(body, loopCtx, runId, loopDynamic, keyPrefix));
+            }
+            catch (error) {
+                if (error instanceof ScopeCompleted)
+                    return { output: primaryOutput(error.output) };
+                throw error;
             }
         }
-        // outputMerge: "last" — lastOutput is already an { output: ... } envelope
-        // from executeNode, so return it directly (no extra wrapping).
-        return lastOutput ?? { output: {} };
+        return { output: lastOutput ?? {} };
     }
     executeGuard(node, ctx) {
         const when = node.metadata.when;
@@ -1245,12 +1230,45 @@ export class WorkflowInterpreter {
     buildContext(ir, input, runId) {
         return { input, steps: {}, workflow: buildWorkflowExpressionContext(ir), run_id: runId };
     }
-    populateStepOutputs(runId, ctx) {
-        for (const nodeState of this.store.listNodeStates(runId)) {
-            if (nodeState.state === "completed" && nodeState.output !== undefined) {
-                ctx.steps[nodeState.nodeId] = nodeState.output;
+    hydrateContextForNodeRetry(node, ctx, runId, targetNodeKey, dynamic, keyPrefix) {
+        const nodeKey = withNodeKeyPrefix(keyPrefix, resolveNodeKey(node.keyTemplate, dynamic));
+        if (nodeKey === targetNodeKey)
+            return { ctx, dynamic };
+        const state = this.store.readNodeState(runId, nodeKey);
+        if (state?.state === "completed" && state.output !== undefined && node.metadata.implicit !== true) {
+            ctx.steps[node.id] = state.output;
+            return undefined;
+        }
+        if (node.kind === "pipeline") {
+            const frame = node.metadata.implicit === true ? ctx : { ...ctx, steps: { ...ctx.steps } };
+            for (const child of node.children ?? []) {
+                const found = this.hydrateContextForNodeRetry(child, frame, runId, targetNodeKey, dynamic, keyPrefix);
+                if (found)
+                    return found;
             }
+            return undefined;
         }
+        if (node.kind === "parallel") {
+            for (const branch of node.branches ?? []) {
+                const branchCtx = { ...ctx, steps: { ...ctx.steps } };
+                const branchDynamic = nestedParallelBranchDynamic(dynamic, branch.id);
+                const found = this.hydrateContextForNodeRetry(branch.child, branchCtx, runId, targetNodeKey, branchDynamic, keyPrefix);
+                if (found)
+                    return found;
+            }
+            return undefined;
+        }
+        for (const child of node.children ?? []) {
+            const found = this.hydrateContextForNodeRetry(child, ctx, runId, targetNodeKey, dynamic, keyPrefix);
+            if (found)
+                return found;
+        }
+        for (const branch of node.branches ?? []) {
+            const found = this.hydrateContextForNodeRetry(branch.child, ctx, runId, targetNodeKey, dynamic, keyPrefix);
+            if (found)
+                return found;
+        }
+        return undefined;
     }
     /** Extract the parent dynamic value-context (fanout item / loop round) from a context, if any. */
     captureDynamicContext(ctx) {
@@ -1288,33 +1306,21 @@ export class WorkflowInterpreter {
             ctx.loop = snapshot.loop;
     }
     findNodeByKey(root, nodeKey) {
-        // Node keys contain dynamic dimensions (e.g. "workflow/mapped/item:0/lane:0")
-        // but IR nodes have template keys without dynamics. Match by extracting
-        // the nodePath from the resolved key and comparing to the template.
-        // The nodePath is always the prefix before any dynamic segments.
-        // We match by the IR node's id since that's unique and stable.
-        const nodeId = this.extractNodeIdFromKey(nodeKey);
-        return this.findNodeById(root, nodeId);
-    }
-    /** Extract the step ID from a resolved node key. The ID is the last path segment before dynamic dims. */
-    extractNodeIdFromKey(nodeKey) {
         const staticPath = staticNodePathFromKey(nodeKey);
-        return staticPath.split("/").at(-1) ?? nodeKey;
+        return this.findNodeByPath(root, staticPath);
     }
-    findNodeById(root, nodeId) {
-        if (root.id === nodeId)
+    findNodeByPath(root, staticPath) {
+        if (root.nodePath.join("/") === staticPath)
             return root;
         for (const child of root.children ?? []) {
-            const found = this.findNodeById(child, nodeId);
+            const found = this.findNodeByPath(child, staticPath);
             if (found)
                 return found;
         }
         for (const branch of root.branches ?? []) {
-            for (const child of branch.children) {
-                const found = this.findNodeById(child, nodeId);
-                if (found)
-                    return found;
-            }
+            const found = this.findNodeByPath(branch.child, staticPath);
+            if (found)
+                return found;
         }
         return undefined;
     }
@@ -1551,6 +1557,12 @@ function hookAgentTelemetry(state) {
     }
     return result;
 }
+function primaryOutput(value) {
+    return isRecord(value) && "output" in value ? value.output : value;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 /** Generate a locally sortable run ID: yyyyMMddHHmmss + 20 uppercase hex chars. */
 export function generateRunId(now = new Date()) {
     const pad = (n) => String(n).padStart(2, "0");
@@ -1564,12 +1576,52 @@ export function generateRunId(now = new Date()) {
     ].join("");
     return `${timestamp}${randomBytes(10).toString("hex").toUpperCase()}`;
 }
-function nestedParallelBranchDynamic(dynamic, branchIndex) {
-    const branchId = String(branchIndex);
-    return {
-        ...dynamic,
-        parallelBranchId: dynamic.parallelBranchId === undefined ? branchId : `${dynamic.parallelBranchId}.${branchId}`
-    };
+function nestedParallelBranchDynamic(dynamic, branchId) {
+    const current = currentDynamicFrame(dynamic);
+    const nextBranchId = current.parallelBranchId === undefined ? branchId : `${current.parallelBranchId}.${branchId}`;
+    return replaceCurrentDynamicFrame(dynamic, { ...current, parallelBranchId: nextBranchId });
+}
+function appendDynamicFrame(dynamic, frame) {
+    const frames = [...dynamicFrames(dynamic), frame];
+    return withCollapsedDynamic(frames);
+}
+function appendDynamicFrames(dynamic, child) {
+    return withCollapsedDynamic([...dynamicFrames(dynamic), ...dynamicFrames(child)]);
+}
+function replaceCurrentDynamicFrame(dynamic, frame) {
+    const frames = dynamicFrames(dynamic);
+    if (frames.length === 0)
+        return withCollapsedDynamic([frame]);
+    return withCollapsedDynamic([...frames.slice(0, -1), frame]);
+}
+function currentDynamicFrame(dynamic) {
+    return dynamicFrames(dynamic).at(-1) ?? {};
+}
+function dynamicFrames(dynamic) {
+    if (dynamic.frames && dynamic.frames.length > 0)
+        return dynamic.frames;
+    const { frames: _frames, ...frame } = dynamic;
+    return isEmptyDynamicFrame(frame) ? [] : [frame];
+}
+function withCollapsedDynamic(frames) {
+    const collapsed = { frames };
+    for (const frame of frames) {
+        if (frame.loopRound !== undefined)
+            collapsed.loopRound = frame.loopRound;
+        if (frame.fanoutItemId !== undefined)
+            collapsed.fanoutItemId = frame.fanoutItemId;
+        if (frame.laneId !== undefined)
+            collapsed.laneId = frame.laneId;
+        if (frame.parallelBranchId !== undefined)
+            collapsed.parallelBranchId = frame.parallelBranchId;
+    }
+    return collapsed;
+}
+function isEmptyDynamicFrame(frame) {
+    return frame.loopRound === undefined &&
+        frame.fanoutItemId === undefined &&
+        frame.laneId === undefined &&
+        frame.parallelBranchId === undefined;
 }
 /** Find the immediate parent IR node of `childId`, or undefined for the root. */
 function findParentNode(node, childId) {
@@ -1581,13 +1633,11 @@ function findParentNode(node, childId) {
             return found;
     }
     for (const branch of node.branches ?? []) {
-        for (const child of branch.children) {
-            if (child.id === childId)
-                return node;
-            const found = findParentNode(child, childId);
-            if (found)
-                return found;
-        }
+        if (branch.child.id === childId)
+            return node;
+        const found = findParentNode(branch.child, childId);
+        if (found)
+            return found;
     }
     return undefined;
 }