@sweny-ai/core 0.1.73 → 0.1.75

package/dist/__tests__/executor.test.js

@@ -483,7 +483,7 @@ describe("executor", () => {
             const { results } = await execute(verifyWorkflow, {}, { skills: createSkillMap([]), claude, config: {} });
             const r = results.get("create");
             expect(r.status).toBe("failed");
-            expect(r.data.error).toMatch(/verify\.any_tool_called failed/);
+            expect(r.data.error).toMatch(/verify failed:.*any_tool_called/s);
             expect(r.data.error).toMatch(/linear_create_issue/);
         });
         it("marks node failed when required tool erred (output.error set)", async () => {
@@ -537,5 +537,200 @@ describe("executor", () => {
             expect(results.get("create").status).toBe("failed");
             expect(results.get("create").data.error).toBe("max_turns");
         });
+        it("marks node failed when all_tools_called missing a required tool", async () => {
+            const wf = {
+                id: "wf",
+                name: "wf",
+                description: "",
+                entry: "n",
+                nodes: {
+                    n: {
+                        name: "N",
+                        instruction: "Do",
+                        skills: [],
+                        verify: { all_tools_called: ["a", "b"] },
+                    },
+                },
+                edges: [],
+            };
+            const claude = {
+                async run() {
+                    return {
+                        status: "success",
+                        data: {},
+                        toolCalls: [{ tool: "a", input: {}, output: { ok: true } }],
+                    };
+                },
+                async evaluate(opts) {
+                    return opts.choices[0]?.id;
+                },
+            };
+            const { results } = await execute(wf, {}, { skills: createSkillMap([]), claude, config: {} });
+            const r = results.get("n");
+            expect(r.status).toBe("failed");
+            expect(r.data.error).toMatch(/verify failed.*all_tools_called.*\[b\]/s);
+        });
+        it("marks node failed when no_tool_called was violated", async () => {
+            const wf = {
+                id: "wf",
+                name: "wf",
+                description: "",
+                entry: "n",
+                nodes: {
+                    n: {
+                        name: "N",
+                        instruction: "Do",
+                        skills: [],
+                        verify: { no_tool_called: ["force_push"] },
+                    },
+                },
+                edges: [],
+            };
+            const claude = {
+                async run() {
+                    return {
+                        status: "success",
+                        data: {},
+                        toolCalls: [{ tool: "force_push", input: {}, output: { ok: true } }],
+                    };
+                },
+                async evaluate(opts) {
+                    return opts.choices[0]?.id;
+                },
+            };
+            const { results } = await execute(wf, {}, { skills: createSkillMap([]), claude, config: {} });
+            const r = results.get("n");
+            expect(r.status).toBe("failed");
+            expect(r.data.error).toMatch(/verify failed.*no_tool_called.*force_push/s);
+        });
+        it("marks node failed when output_required is missing", async () => {
+            const wf = {
+                id: "wf",
+                name: "wf",
+                description: "",
+                entry: "n",
+                nodes: {
+                    n: {
+                        name: "N",
+                        instruction: "Do",
+                        skills: [],
+                        verify: { output_required: ["prUrl"] },
+                    },
+                },
+                edges: [],
+            };
+            const claude = {
+                async run() {
+                    return { status: "success", data: { branch: "main" }, toolCalls: [] };
+                },
+                async evaluate(opts) {
+                    return opts.choices[0]?.id;
+                },
+            };
+            const { results } = await execute(wf, {}, { skills: createSkillMap([]), claude, config: {} });
+            const r = results.get("n");
+            expect(r.status).toBe("failed");
+            expect(r.data.error).toMatch(/verify failed.*output_required.*'prUrl'/s);
+        });
+        it("marks node failed when output_matches assertion fails", async () => {
+            const wf = {
+                id: "wf",
+                name: "wf",
+                description: "",
+                entry: "n",
+                nodes: {
+                    n: {
+                        name: "N",
+                        instruction: "Do",
+                        skills: [],
+                        verify: { output_matches: [{ path: "branch", matches: "^sweny/" }] },
+                    },
+                },
+                edges: [],
+            };
+            const claude = {
+                async run() {
+                    return { status: "success", data: { branch: "main" }, toolCalls: [] };
+                },
+                async evaluate(opts) {
+                    return opts.choices[0]?.id;
+                },
+            };
+            const { results } = await execute(wf, {}, { skills: createSkillMap([]), claude, config: {} });
+            const r = results.get("n");
+            expect(r.status).toBe("failed");
+            expect(r.data.error).toMatch(/verify failed.*output_matches.*'branch'/s);
+        });
+        it("aggregates multiple verify failures into one error string", async () => {
+            const wf = {
+                id: "wf",
+                name: "wf",
+                description: "",
+                entry: "n",
+                nodes: {
+                    n: {
+                        name: "N",
+                        instruction: "Do",
+                        skills: [],
+                        verify: {
+                            all_tools_called: ["create_pr"],
+                            output_required: ["prUrl"],
+                        },
+                    },
+                },
+                edges: [],
+            };
+            const claude = {
+                async run() {
+                    return { status: "success", data: {}, toolCalls: [] };
+                },
+                async evaluate(opts) {
+                    return opts.choices[0]?.id;
+                },
+            };
+            const { results } = await execute(wf, {}, { skills: createSkillMap([]), claude, config: {} });
+            const r = results.get("n");
+            expect(r.status).toBe("failed");
+            expect(r.data.error).toMatch(/all_tools_called/);
+            expect(r.data.error).toMatch(/output_required/);
+        });
+        it("passes a node when every declared check passes", async () => {
+            const wf = {
+                id: "wf",
+                name: "wf",
+                description: "",
+                entry: "n",
+                nodes: {
+                    n: {
+                        name: "N",
+                        instruction: "Do",
+                        skills: [],
+                        verify: {
+                            all_tools_called: ["create_pr"],
+                            no_tool_called: ["force_push"],
+                            output_required: ["prUrl"],
+                            output_matches: [{ path: "prUrl", matches: "^https://" }],
+                        },
+                    },
+                },
+                edges: [],
+            };
+            const claude = {
+                async run() {
+                    return {
+                        status: "success",
+                        data: { prUrl: "https://github.com/x/y/pull/1" },
+                        toolCalls: [{ tool: "create_pr", input: {}, output: { ok: true } }],
+                    };
+                },
+                async evaluate(opts) {
+                    return opts.choices[0]?.id;
+                },
+            };
+            const { results } = await execute(wf, {}, { skills: createSkillMap([]), claude, config: {} });
+            const r = results.get("n");
+            expect(r.status).toBe("success");
+            expect(r.data.error).toBeUndefined();
+        });
     });
 });

package/dist/__tests__/schema.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { workflowZ, nodeZ, edgeZ, skillZ, toolZ, mcpServerConfigZ, skillDefinitionZ, parseWorkflow, validateWorkflow, workflowJsonSchema, } from "../schema.js";
+import { workflowZ, nodeZ, nodeVerifyZ, edgeZ, skillZ, toolZ, mcpServerConfigZ, skillDefinitionZ, parseWorkflow, validateWorkflow, workflowJsonSchema, } from "../schema.js";
 import { triageWorkflow, implementWorkflow } from "../workflows/index.js";
 // ─── Test fixtures ───────────────────────────────────────────────
 const validWorkflow = {
@@ -57,6 +57,73 @@ describe("Zod schemas", () => {
         it("rejects verify with empty any_tool_called", () => {
             expect(() => nodeZ.parse({ name: "S", instruction: "I", verify: { any_tool_called: [] } })).toThrow();
         });
+        it("accepts all_tools_called", () => {
+            const v = nodeVerifyZ.parse({ all_tools_called: ["a", "b"] });
+            expect(v.all_tools_called).toEqual(["a", "b"]);
+        });
+        it("accepts no_tool_called", () => {
+            const v = nodeVerifyZ.parse({ no_tool_called: ["force_push"] });
+            expect(v.no_tool_called).toEqual(["force_push"]);
+        });
+        it("accepts output_required", () => {
+            const v = nodeVerifyZ.parse({ output_required: ["prUrl", "branch"] });
+            expect(v.output_required).toEqual(["prUrl", "branch"]);
+        });
+        it("accepts output_matches with each operator", () => {
+            const v = nodeVerifyZ.parse({
+                output_matches: [
+                    { path: "a", equals: 1 },
+                    { path: "b", in: ["x", "y"] },
+                    { path: "c", matches: "^foo" },
+                ],
+            });
+            expect(v.output_matches).toHaveLength(3);
+        });
+        it("accepts a combination of multiple checks", () => {
+            const v = nodeVerifyZ.parse({
+                any_tool_called: ["a"],
+                output_required: ["x"],
+                output_matches: [{ path: "x", equals: 1 }],
+            });
+            expect(v.any_tool_called).toBeDefined();
+            expect(v.output_required).toBeDefined();
+            expect(v.output_matches).toBeDefined();
+        });
+        it("rejects an output_matches entry with zero operators", () => {
+            expect(() => nodeVerifyZ.parse({ output_matches: [{ path: "a" }] })).toThrow();
+        });
+        it("rejects an output_matches entry with two operators", () => {
+            expect(() => nodeVerifyZ.parse({ output_matches: [{ path: "a", equals: 1, in: [1, 2] }] })).toThrow();
+        });
+        it("rejects an output_matches entry with equals + matches", () => {
+            expect(() => nodeVerifyZ.parse({ output_matches: [{ path: "a", equals: 1, matches: "^x$" }] })).toThrow();
+        });
+        it("rejects an output_matches entry with in + matches", () => {
+            expect(() => nodeVerifyZ.parse({ output_matches: [{ path: "a", in: [1, 2], matches: "^x$" }] })).toThrow();
+        });
+        it("rejects an output_matches entry with all three operators", () => {
+            expect(() => nodeVerifyZ.parse({ output_matches: [{ path: "a", equals: 1, in: [1], matches: "^x$" }] })).toThrow();
+        });
+        it("accepts equals: null as a valid operator value", () => {
+            // null IS a valid value to assert equality against; only `undefined` means
+            // "not set". Schema must distinguish.
+            expect(() => nodeVerifyZ.parse({ output_matches: [{ path: "a", equals: null }] })).not.toThrow();
+        });
+        it("rejects an output_matches entry with empty path", () => {
+            expect(() => nodeVerifyZ.parse({ output_matches: [{ path: "", equals: 1 }] })).toThrow();
+        });
+        it("rejects empty output_required", () => {
+            expect(() => nodeVerifyZ.parse({ output_required: [] })).toThrow();
+        });
+        it("rejects empty all_tools_called", () => {
+            expect(() => nodeVerifyZ.parse({ all_tools_called: [] })).toThrow();
+        });
+        it("rejects empty no_tool_called", () => {
+            expect(() => nodeVerifyZ.parse({ no_tool_called: [] })).toThrow();
+        });
+        it("rejects empty output_matches array", () => {
+            expect(() => nodeVerifyZ.parse({ output_matches: [] })).toThrow();
+        });
     });
     describe("edgeZ", () => {
         it("parses a simple edge", () => {

package/dist/__tests__/verify.test.d.ts

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