@fitchmultz/pi-subagents 0.0.0-stage → 0.44.4

package/dist/runs/shared/workflow-graph.js

@@ -0,0 +1,214 @@
+import { isDynamicParallelStep, isParallelStep } from "../../shared/settings.js";
+/** Pending fanouts keep their own slot until their actual children are known. */
+export function workflowAgentNodes(graph) {
+    return graph.nodes.flatMap((node) => node.children?.length ? node.children
+        : node.kind === "dynamic-parallel-group" && node.status !== "completed" && node.status !== "complete" ? [node]
+            : node.children ?? [node]);
+}
+function normalizeStatus(status) {
+    switch (status) {
+        case "complete":
+        case "completed":
+            return "completed";
+        case "running":
+            return "running";
+        case "failed":
+            return "failed";
+        case "paused":
+            return "paused";
+        case "blocked":
+            return "blocked";
+        case "detached":
+            return "detached";
+        case "timed-out":
+            return "timed-out";
+        case "pending":
+            return "pending";
+        default:
+            return undefined;
+    }
+}
+function resultStatus(result) {
+    if (!result)
+        return undefined;
+    if (result.detached)
+        return "detached";
+    if (result.timedOut)
+        return "timed-out";
+    if (result.interrupted)
+        return "paused";
+    return result.exitCode === 0 ? result.acceptance?.status === "blocked" ? "blocked" : "completed" : "failed";
+}
+function nodeStatus(input, flatIndex) {
+    return normalizeStatus(input.stepStatuses?.[flatIndex]?.status)
+        ?? resultStatus(input.results?.[flatIndex])
+        ?? (input.currentFlatIndex === flatIndex ? "running" : "pending");
+}
+function pushPhase(phases, phase, nodeId) {
+    if (!phase)
+        return;
+    let group = phases.find((candidate) => candidate.title === phase);
+    if (!group) {
+        group = { title: phase, nodeIds: [] };
+        phases.push(group);
+    }
+    group.nodeIds.push(nodeId);
+}
+function seqLabel(step, stepIndex) {
+    return step.label?.trim() || step.agent || `Step ${stepIndex + 1}`;
+}
+function summarizeParallelStatuses(statuses) {
+    if (statuses.some((status) => status === "running"))
+        return "running";
+    if (statuses.some((status) => status === "failed"))
+        return "failed";
+    if (statuses.some((status) => status === "timed-out"))
+        return "timed-out";
+    if (statuses.some((status) => status === "blocked"))
+        return "blocked";
+    if (statuses.some((status) => status === "paused"))
+        return "paused";
+    if (statuses.some((status) => status === "detached"))
+        return "detached";
+    if (statuses.length > 0 && statuses.every((status) => status === "completed"))
+        return "completed";
+    if (statuses.some((status) => status === "completed"))
+        return "running";
+    return "pending";
+}
+export function buildWorkflowGraphSnapshot(input) {
+    const nodes = [];
+    const phases = [];
+    let flatIndex = 0;
+    let currentNodeId;
+    for (let stepIndex = 0; stepIndex < input.steps.length; stepIndex++) {
+        const step = input.steps[stepIndex];
+        if (isParallelStep(step)) {
+            const groupId = `step-${stepIndex}`;
+            const children = [];
+            const childStatuses = [];
+            for (let taskIndex = 0; taskIndex < step.parallel.length; taskIndex++) {
+                const task = step.parallel[taskIndex];
+                const status = nodeStatus(input, flatIndex);
+                childStatuses.push(status);
+                const childId = `step-${stepIndex}-agent-${taskIndex}`;
+                const child = {
+                    id: childId,
+                    kind: "agent",
+                    agent: task.agent,
+                    phase: task.phase,
+                    label: task.label?.trim() || task.agent || `Agent ${taskIndex + 1}`,
+                    status,
+                    flatIndex,
+                    stepIndex,
+                    outputName: task.as,
+                    structured: Boolean(task.outputSchema),
+                    acceptanceStatus: input.results?.[flatIndex]?.acceptance?.status,
+                    error: input.stepStatuses?.[flatIndex]?.error ?? input.results?.[flatIndex]?.error,
+                };
+                children.push(child);
+                pushPhase(phases, task.phase, childId);
+                if (status === "running" || input.currentFlatIndex === flatIndex)
+                    currentNodeId = childId;
+                flatIndex++;
+            }
+            const groupStatus = summarizeParallelStatuses(childStatuses);
+            if (input.currentStepIndex === stepIndex && !currentNodeId)
+                currentNodeId = groupId;
+            nodes.push({
+                id: groupId,
+                kind: "parallel-group",
+                label: step.parallel.length === 1 ? "Parallel task" : `Parallel group (${step.parallel.length})`,
+                status: groupStatus,
+                stepIndex,
+                children,
+            });
+            continue;
+        }
+        if (isDynamicParallelStep(step)) {
+            const groupId = `step-${stepIndex}`;
+            const materialized = input.dynamicChildren?.[stepIndex] ?? [];
+            const groupOverride = input.dynamicGroupStatuses?.[stepIndex];
+            const children = [];
+            const childStatuses = [];
+            for (let taskIndex = 0; taskIndex < materialized.length; taskIndex++) {
+                const task = materialized[taskIndex];
+                const status = nodeStatus(input, task.flatIndex);
+                childStatuses.push(status);
+                const childId = `step-${stepIndex}-item-${task.itemKey.replace(/[^a-zA-Z0-9_-]/g, "-")}`;
+                const child = {
+                    id: childId,
+                    kind: "agent",
+                    agent: task.agent,
+                    phase: step.parallel.phase ?? step.phase,
+                    label: task.label?.trim() || step.parallel.label?.trim() || `${task.agent} ${task.itemKey}`,
+                    status,
+                    flatIndex: task.flatIndex,
+                    stepIndex,
+                    itemKey: task.itemKey,
+                    outputName: task.outputName,
+                    structured: task.structured,
+                    acceptanceStatus: input.results?.[task.flatIndex]?.acceptance?.status,
+                    error: input.stepStatuses?.[task.flatIndex]?.error ?? input.results?.[task.flatIndex]?.error ?? task.error,
+                };
+                children.push(child);
+                pushPhase(phases, child.phase, childId);
+                if (status === "running" || input.currentFlatIndex === task.flatIndex)
+                    currentNodeId = childId;
+            }
+            const groupStatus = groupOverride?.status ?? (children.length > 0 ? summarizeParallelStatuses(childStatuses) : (input.currentStepIndex === stepIndex ? "running" : "pending"));
+            if (input.currentStepIndex === stepIndex && !currentNodeId)
+                currentNodeId = groupId;
+            nodes.push({
+                id: groupId,
+                kind: "dynamic-parallel-group",
+                label: step.label?.trim() || step.parallel.label?.trim() || `Dynamic fanout (${step.collect.as})`,
+                status: groupStatus,
+                stepIndex,
+                outputName: step.collect.as,
+                structured: Boolean(step.collect.outputSchema),
+                acceptanceStatus: groupOverride?.acceptance?.status,
+                error: groupOverride?.error,
+                dynamic: {
+                    sourceOutput: step.expand.from.output,
+                    sourcePath: step.expand.from.path,
+                    itemName: step.expand.item ?? "item",
+                    maxItems: step.expand.maxItems,
+                    collectAs: step.collect.as,
+                },
+                children,
+            });
+            if (materialized.length > 0)
+                flatIndex = Math.max(flatIndex, ...materialized.map((child) => child.flatIndex + 1));
+            continue;
+        }
+        const seq = step;
+        const status = nodeStatus(input, flatIndex);
+        const id = `step-${stepIndex}`;
+        nodes.push({
+            id,
+            kind: "step",
+            agent: seq.agent,
+            phase: seq.phase,
+            label: seqLabel(seq, stepIndex),
+            status,
+            flatIndex,
+            stepIndex,
+            outputName: seq.as,
+            structured: Boolean(seq.outputSchema),
+            acceptanceStatus: input.results?.[flatIndex]?.acceptance?.status,
+            error: input.stepStatuses?.[flatIndex]?.error ?? input.results?.[flatIndex]?.error,
+        });
+        pushPhase(phases, seq.phase, id);
+        if (status === "running" || input.currentFlatIndex === flatIndex || input.currentStepIndex === stepIndex)
+            currentNodeId = id;
+        flatIndex++;
+    }
+    return {
+        runId: input.runId,
+        mode: input.mode ?? "chain",
+        phases,
+        nodes,
+        currentNodeId,
+    };
+}

package/dist/runs/shared/workflow-policy.js

@@ -0,0 +1,84 @@
+import { outputEntryFromResult } from "./chain-outputs.js";
+import { collectDynamicResults, validateDynamicCollection } from "./dynamic-fanout.js";
+import { aggregateParallelOutputs, FAIL_FAST_REASON, mapConcurrent } from "./parallel-utils.js";
+export function workflowChildSucceeded(result) {
+    return result.exitCode === 0 && !result.interrupted && !result.detached && !result.timedOut && result.acceptance?.status !== "blocked";
+}
+export async function runParallelTasks(input) {
+    const failFast = new AbortController();
+    let stopped;
+    return mapConcurrent(input.tasks, input.concurrency, async (task, index) => {
+        const reason = input.signal?.aborted ? "cancelled" : input.interruptSignal?.aborted ? "interrupted" : stopped;
+        if (reason)
+            return input.stoppedTask(task, index, reason);
+        const result = await input.runTask(task, index, failFast.signal);
+        // A selected-child stop must not skip independent siblings; whole-group stops use interruptSignal.
+        if (result.detached)
+            stopped ??= "detached";
+        else if (result.timedOut)
+            stopped ??= "timed-out";
+        else if (input.failFast && !result.interrupted && !(result.exitCode === 0 && result.acceptance?.status === "blocked") && !workflowChildSucceeded(result)) {
+            stopped ??= "fail-fast";
+            failFast.abort(FAIL_FAST_REASON);
+        }
+        return result;
+    });
+}
+export function completeWorkflowStep(input) {
+    const outputs = {};
+    const failedIndices = [];
+    const timedOutIndex = input.results.findIndex((result) => result.timedOut);
+    const interruptedIndex = input.results.findIndex((result) => result.interrupted);
+    const detachedIndex = input.results.findIndex((result) => result.detached);
+    const blocked = input.results.some((result) => result.exitCode === 0 && result.acceptance?.status === "blocked");
+    for (const [index, result] of input.results.entries()) {
+        if (workflowChildSucceeded(result)) {
+            const name = input.outputNames?.[index];
+            if (name)
+                outputs[name] = outputEntryFromResult(result, input.stepIndex);
+        }
+        else if (!result.timedOut && !result.interrupted && !result.detached && !(result.exitCode === 0 && result.acceptance?.status === "blocked")) {
+            failedIndices.push(index);
+        }
+    }
+    let status = failedIndices.length > 0 ? "failed"
+        : timedOutIndex >= 0 ? "timed-out"
+            : blocked ? "blocked"
+                : interruptedIndex >= 0 ? "paused"
+                    : detachedIndex >= 0 ? "detached" : "completed";
+    let error;
+    let collection;
+    let previousOutput = input.previousOutput;
+    if (status === "completed" && input.dynamic) {
+        const { step, items } = input.dynamic;
+        try {
+            if (items.length !== input.results.length)
+                throw new Error("Dynamic fanout did not complete every child.");
+            collection = collectDynamicResults(step, items, input.results);
+            validateDynamicCollection(step.collect.outputSchema, collection);
+            outputs[step.collect.as] = { text: JSON.stringify(collection), structured: collection, agent: step.parallel.agent, stepIndex: input.stepIndex };
+            previousOutput = items.length === 0 ? "Dynamic fanout produced 0 results." : aggregateParallelOutputs(input.results, (index, agent) => `=== Dynamic Item ${index + 1} (${agent}, key ${items[index]?.key ?? index}) ===`);
+        }
+        catch (cause) {
+            error = cause instanceof Error ? cause.message : String(cause);
+            status = "failed";
+        }
+    }
+    else if (status === "completed") {
+        previousOutput = input.parallel ? aggregateParallelOutputs(input.results) : input.results[0]?.output ?? input.previousOutput;
+    }
+    const advance = status === "completed";
+    return {
+        advance,
+        complete: advance && input.stepIndex + 1 === input.stepCount,
+        status,
+        failedIndices,
+        timedOutIndex,
+        interruptedIndex,
+        detachedIndex,
+        outputs,
+        previousOutput,
+        collection,
+        error,
+    };
+}