@tea-agent/loop-agent 0.1.0

package/dist/workflows/dynamic/validate.js

@@ -0,0 +1,275 @@
+import { AGENT_LIKE_WORKFLOW_NODE_TYPES, ITEM_SELECTOR_WORKFLOW_NODE_TYPES, workflowSpecSchema, workflowNodeSchema, } from "./spec.js";
+import { formatWorkflowValidationIssues, } from "./errors.js";
+export function parseWorkflowSpec(raw) {
+    return workflowSpecSchema.parse(raw);
+}
+function nodePath(node, suffix) {
+    return suffix ? `nodes.${node.id}.${suffix}` : `nodes.${node.id}`;
+}
+function pushIssue(issues, issue) {
+    issues.push(issue);
+}
+function collectSelectorNodeRefs(selector) {
+    const refs = new Set();
+    const pattern = /\.nodes\[['"]([^'"]+)['"]\]/g;
+    let match;
+    while ((match = pattern.exec(selector)) !== null) {
+        refs.add(match[1] ?? "");
+    }
+    return [...refs].filter(Boolean);
+}
+function collectAncestors(nodeId, dependenciesById, seen = new Set()) {
+    for (const dependency of dependenciesById.get(nodeId) ?? []) {
+        if (seen.has(dependency))
+            continue;
+        seen.add(dependency);
+        collectAncestors(dependency, dependenciesById, seen);
+    }
+    return seen;
+}
+function validateAcyclic(spec, issues) {
+    const dependenciesById = new Map(spec.nodes.map((node) => [node.id, node.dependsOn]));
+    const visiting = new Set();
+    const visited = new Set();
+    function visit(id, stack) {
+        if (visited.has(id))
+            return;
+        if (visiting.has(id)) {
+            pushIssue(issues, {
+                type: "cycle",
+                path: `nodes.${id}.dependsOn`,
+                message: `workflow dependency cycle detected: ${[...stack, id].join(" -> ")}`,
+            });
+            return;
+        }
+        visiting.add(id);
+        for (const dependency of dependenciesById.get(id) ?? []) {
+            if (!dependenciesById.has(dependency))
+                continue;
+            visit(dependency, [...stack, id]);
+        }
+        visiting.delete(id);
+        visited.add(id);
+    }
+    for (const node of spec.nodes) {
+        visit(node.id, []);
+    }
+}
+export function validateWorkflowSpec(spec) {
+    const issues = [];
+    const seen = new Set();
+    const nodeIds = new Set(spec.nodes.map((node) => node.id));
+    const dependenciesById = new Map(spec.nodes.map((node) => [node.id, node.dependsOn]));
+    for (const node of spec.nodes) {
+        if (seen.has(node.id)) {
+            pushIssue(issues, {
+                type: "duplicate-node-id",
+                path: nodePath(node),
+                message: `duplicate workflow node id "${node.id}"`,
+            });
+        }
+        seen.add(node.id);
+        for (const dependency of node.dependsOn) {
+            if (dependency === node.id) {
+                pushIssue(issues, {
+                    type: "self-dependency",
+                    path: nodePath(node, "dependsOn"),
+                    message: `node "${node.id}" cannot depend on itself`,
+                });
+            }
+            if (!nodeIds.has(dependency)) {
+                pushIssue(issues, {
+                    type: "missing-dependency",
+                    path: nodePath(node, "dependsOn"),
+                    message: `node "${node.id}" depends on missing node "${dependency}"`,
+                });
+            }
+        }
+        if (AGENT_LIKE_WORKFLOW_NODE_TYPES.has(node.type) && !node.outputSchema) {
+            pushIssue(issues, {
+                type: "missing-output-schema",
+                path: nodePath(node, "outputSchema"),
+                message: `${node.type} node "${node.id}" requires outputSchema`,
+            });
+        }
+        if (ITEM_SELECTOR_WORKFLOW_NODE_TYPES.has(node.type) && !node.itemsFrom) {
+            pushIssue(issues, {
+                type: "missing-items-from",
+                path: nodePath(node, "itemsFrom"),
+                message: `${node.type} node "${node.id}" requires itemsFrom`,
+            });
+        }
+        if (node.itemsFrom) {
+            const refs = collectSelectorNodeRefs(node.itemsFrom);
+            const ancestors = collectAncestors(node.id, dependenciesById);
+            for (const ref of refs) {
+                if (!nodeIds.has(ref)) {
+                    pushIssue(issues, {
+                        type: "items-from-missing-node",
+                        path: nodePath(node, "itemsFrom"),
+                        message: `itemsFrom references missing node "${ref}"`,
+                    });
+                    continue;
+                }
+                if (!ancestors.has(ref)) {
+                    pushIssue(issues, {
+                        type: "items-from-not-upstream",
+                        path: nodePath(node, "itemsFrom"),
+                        message: `itemsFrom node "${ref}" must be an upstream dependency of "${node.id}"`,
+                    });
+                }
+            }
+        }
+        if (node.type === "command") {
+            if (!node.command) {
+                pushIssue(issues, {
+                    type: "missing-command",
+                    path: nodePath(node, "command"),
+                    message: `command node "${node.id}" requires command`,
+                });
+            }
+            else if (spec.permissions.shell.mode !== "allowlist") {
+                pushIssue(issues, {
+                    type: "command-without-allowlist",
+                    path: nodePath(node, "command"),
+                    message: `command node "${node.id}" requires permissions.shell.mode=allowlist`,
+                });
+            }
+            else if (!spec.permissions.shell.commands.includes(node.command)) {
+                pushIssue(issues, {
+                    type: "command-not-allowlisted",
+                    path: nodePath(node, "command"),
+                    message: `command node "${node.id}" command is not listed in permissions.shell.commands`,
+                });
+            }
+        }
+        if (node.type === "loop_until" && !node.maxIterations) {
+            pushIssue(issues, {
+                type: "missing-max-iterations",
+                path: nodePath(node, "maxIterations"),
+                message: `loop_until node "${node.id}" must declare maxIterations`,
+            });
+        }
+        if (node.type === "loop_until") {
+            if (!node.body || node.body.length === 0) {
+                pushIssue(issues, {
+                    type: "missing-loop-body",
+                    path: nodePath(node, "body"),
+                    message: `loop_until node "${node.id}" must declare a non-empty body`,
+                });
+            }
+            for (const [index, bodyNode] of (node.body ?? []).entries()) {
+                const parsed = workflowNodeSchema.safeParse(bodyNode);
+                if (!parsed.success) {
+                    pushIssue(issues, {
+                        type: "invalid-loop-body",
+                        path: nodePath(node, `body.${index}`),
+                        message: `loop_until node "${node.id}" body node ${index} is invalid`,
+                    });
+                }
+            }
+        }
+        if (node.type === "condition") {
+            const ancestors = collectAncestors(node.id, dependenciesById);
+            for (const conditionCase of node.cases ?? []) {
+                if (!nodeIds.has(conditionCase.then)) {
+                    pushIssue(issues, {
+                        type: "missing-condition-target",
+                        path: nodePath(node, "cases"),
+                        message: `condition node "${node.id}" references missing then target "${conditionCase.then}"`,
+                    });
+                }
+                for (const ref of collectSelectorNodeRefs(conditionCase.when)) {
+                    if (!nodeIds.has(ref) || !ancestors.has(ref)) {
+                        pushIssue(issues, {
+                            type: "condition-source-not-upstream",
+                            path: nodePath(node, "cases"),
+                            message: `condition node "${node.id}" reads non-upstream node "${ref}"`,
+                        });
+                    }
+                }
+            }
+            if (node.default && !nodeIds.has(node.default)) {
+                pushIssue(issues, {
+                    type: "missing-condition-target",
+                    path: nodePath(node, "default"),
+                    message: `condition node "${node.id}" references missing default target "${node.default}"`,
+                });
+            }
+        }
+        if (node.type === "artifact_transform" && !node.transform) {
+            pushIssue(issues, {
+                type: "invalid-artifact-transform",
+                path: nodePath(node, "transform"),
+                message: `artifact_transform node "${node.id}" requires deterministic transform`,
+            });
+        }
+        if (node.type === "verify_agent" && node.producerNodeId === node.id) {
+            pushIssue(issues, {
+                type: "producer-verifies-own-finding",
+                path: nodePath(node, "producerNodeId"),
+                message: `verify_agent node "${node.id}" cannot verify findings it produced`,
+            });
+        }
+        if (node.type === "reduce_agent" && node.reducer) {
+            for (const [field, selector] of [
+                ["findingsFrom", node.reducer.findingsFrom],
+                ["verificationsFrom", node.reducer.verificationsFrom],
+            ]) {
+                const refs = collectSelectorNodeRefs(selector);
+                if (refs.length === 0) {
+                    pushIssue(issues, {
+                        type: "missing-reducer-source",
+                        path: nodePath(node, `reducer.${field}`),
+                        message: `reduce_agent node "${node.id}" reducer.${field} must reference a workflow node output`,
+                    });
+                    continue;
+                }
+                const ancestors = collectAncestors(node.id, dependenciesById);
+                for (const ref of refs) {
+                    if (!nodeIds.has(ref) || !ancestors.has(ref)) {
+                        pushIssue(issues, {
+                            type: "missing-reducer-source",
+                            path: nodePath(node, `reducer.${field}`),
+                            message: `reduce_agent node "${node.id}" reducer.${field} must reference an upstream node output`,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    if (!nodeIds.has(spec.final.from)) {
+        pushIssue(issues, {
+            type: "missing-final-node",
+            path: "final.from",
+            message: `final.from references missing node "${spec.final.from}"`,
+        });
+    }
+    if (spec.permissions.edits !== "deny") {
+        const hasWriteScope = (spec.permissions.allowedPaths?.length ?? 0) > 0 &&
+            (spec.permissions.forbiddenPaths?.length ?? 0) > 0 &&
+            (spec.permissions.writeSet?.length ?? 0) > 0;
+        if (!hasWriteScope) {
+            pushIssue(issues, {
+                type: "write-scope-required",
+                path: "permissions",
+                message: "workflows with edits enabled require allowedPaths, forbiddenPaths, and writeSet",
+            });
+        }
+        if (!spec.nodes.some((node) => node.type === "human_gate")) {
+            pushIssue(issues, {
+                type: "write-human-gate-required",
+                path: "nodes",
+                message: "workflows with edits enabled require a human_gate node",
+            });
+        }
+    }
+    validateAcyclic(spec, issues);
+    return issues;
+}
+export function assertValidWorkflowSpec(spec) {
+    const issues = validateWorkflowSpec(spec);
+    if (issues.length > 0) {
+        throw new Error(`invalid WorkflowSpec: ${formatWorkflowValidationIssues(issues)}`);
+    }
+}