@sweny-ai/core 0.1.76 → 0.1.77

package/dist/schema.js

@@ -101,6 +101,21 @@ export const nodeVerifyZ = z
     v.output_matches !== undefined, {
     message: "verify must declare at least one check (any_tool_called, all_tools_called, no_tool_called, output_required, or output_matches)",
 });
+export const nodeRequiresZ = z
+    .object({
+    output_required: z.array(z.string().min(1)).min(1).optional(),
+    output_matches: z.array(outputMatchZ).min(1).optional(),
+    on_fail: z.enum(["fail", "skip"]).optional(),
+})
+    .refine((r) => r.output_required !== undefined || r.output_matches !== undefined, {
+    message: "requires must declare at least one check (output_required or output_matches)",
+});
+const retryInstructionAutoZ = z.object({ auto: z.literal(true) }).strict();
+const retryInstructionReflectZ = z.object({ reflect: z.string().min(1) }).strict();
+export const nodeRetryZ = z.object({
+    max: z.number().int().min(1),
+    instruction: z.union([z.string().min(1), retryInstructionAutoZ, retryInstructionReflectZ]).optional(),
+});
 export const nodeZ = z.object({
     name: z.string().min(1),
     instruction: sourceZ,
@@ -110,6 +125,8 @@ export const nodeZ = z.object({
     rules: nodeSourcesZ.optional(),
     context: nodeSourcesZ.optional(),
     verify: nodeVerifyZ.optional(),
+    requires: nodeRequiresZ.optional(),
+    retry: nodeRetryZ.optional(),
 });
 export const edgeZ = z.object({
     from: z.string().min(1),
@@ -375,6 +392,86 @@ export const workflowJsonSchema = {
                         $ref: "#/$defs/NodeSources",
                         description: "Per-node context. Additive by default; set { only: true } to block cascade.",
                     },
+                    verify: {
+                        type: "object",
+                        description: "Machine-checked post-conditions evaluated after the LLM finishes.",
+                        additionalProperties: false,
+                        properties: {
+                            any_tool_called: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 },
+                            all_tools_called: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 },
+                            no_tool_called: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 },
+                            output_required: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 },
+                            output_matches: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    required: ["path"],
+                                    additionalProperties: false,
+                                    properties: {
+                                        path: { type: "string", minLength: 1 },
+                                        equals: {},
+                                        in: { type: "array" },
+                                        matches: { type: "string", minLength: 1 },
+                                    },
+                                },
+                                minItems: 1,
+                            },
+                        },
+                    },
+                    requires: {
+                        type: "object",
+                        description: "Pre-condition checks evaluated before the LLM runs.",
+                        additionalProperties: false,
+                        properties: {
+                            output_required: {
+                                type: "array",
+                                items: { type: "string", minLength: 1 },
+                                minItems: 1,
+                            },
+                            output_matches: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    required: ["path"],
+                                    additionalProperties: false,
+                                    properties: {
+                                        path: { type: "string", minLength: 1 },
+                                        equals: {},
+                                        in: { type: "array" },
+                                        matches: { type: "string", minLength: 1 },
+                                    },
+                                },
+                                minItems: 1,
+                            },
+                            on_fail: { type: "string", enum: ["fail", "skip"] },
+                        },
+                    },
+                    retry: {
+                        type: "object",
+                        description: "Node-local retry on verify failure.",
+                        required: ["max"],
+                        additionalProperties: false,
+                        properties: {
+                            max: { type: "integer", minimum: 1 },
+                            instruction: {
+                                oneOf: [
+                                    { type: "string", minLength: 1 },
+                                    {
+                                        type: "object",
+                                        required: ["auto"],
+                                        additionalProperties: false,
+                                        properties: { auto: { const: true } },
+                                    },
+                                    {
+                                        type: "object",
+                                        required: ["reflect"],
+                                        additionalProperties: false,
+                                        properties: { reflect: { type: "string", minLength: 1 } },
+                                    },
+                                ],
+                            },
+                        },
+                    },
                 },
             },
         },

package/dist/testing.d.ts

@@ -38,6 +38,8 @@ export interface MockClaudeOptions {
     routes?: Record<string, string>;
     /** Workflow definition — enables instruction-based node matching (required for branching workflows) */
     workflow?: Workflow;
+    /** Scripted handler for `ask()` calls. */
+    ask?: (instruction: string, context: Record<string, unknown>) => string;
 }
 /**
  * A mock Claude client that follows a script.
@@ -51,6 +53,7 @@ export declare class MockClaude implements Claude {
     private responses;
     private routes;
     private instructionMap;
+    private askFn?;
     constructor(opts: MockClaudeOptions);
     /** Returns the order in which nodes were executed */
     get executedNodes(): string[];
@@ -68,6 +71,10 @@ export declare class MockClaude implements Claude {
             description: string;
         }[];
     }): Promise<string>;
+    ask(opts: {
+        instruction: string;
+        context: Record<string, unknown>;
+    }): Promise<string>;
     /**
      * Identify which node is being executed.
      *

package/dist/testing.js

@@ -32,9 +32,11 @@ export class MockClaude {
     responses;
     routes;
     instructionMap; // instruction text → node ID
+    askFn;
     constructor(opts) {
         this.responses = opts.responses;
         this.routes = opts.routes ?? {};
+        this.askFn = opts.ask;
         // Build reverse map: instruction → node ID (for accurate matching in branching workflows)
         this.instructionMap = new Map();
         if (opts.workflow) {
@@ -98,6 +100,11 @@ export class MockClaude {
         // Default: first choice
         return opts.choices[0].id;
     }
+    async ask(opts) {
+        if (this.askFn)
+            return this.askFn(opts.instruction, opts.context);
+        return "";
+    }
     /**
      * Identify which node is being executed.
      *

package/dist/types.d.ts

@@ -73,6 +73,50 @@ export interface NodeVerify {
     /** Each assertion must hold against `result.data`. */
     output_matches?: OutputMatch[];
 }
+/**
+ * Machine-checked pre-condition for a node.
+ *
+ * Evaluated by the executor BEFORE the LLM runs. If any declared check fails,
+ * the node is marked `failed` (or `skipped` when `on_fail: "skip"`) and the
+ * LLM is never invoked.
+ *
+ * Path roots resolve against the cross-node context map:
+ *   { input: <runtime input>, [priorNodeId]: <data of prior node>, ... }
+ *
+ * Reuses the same path grammar as `verify` (dotted segments, `[*]` wildcard,
+ * optional `all:`/`any:` prefix).
+ */
+export interface NodeRequires {
+    /** Listed paths must be present and non-null in the context map. */
+    output_required?: string[];
+    /** Each assertion must hold against the context map. */
+    output_matches?: OutputMatch[];
+    /** Action when checks fail. Default: "fail". */
+    on_fail?: "fail" | "skip";
+}
+/**
+ * Node-local retry on verify failure.
+ *
+ * Re-runs the LLM up to `max` additional times, prepending feedback derived
+ * from the verify failure. Triggered ONLY by verify failure — not by tool/API
+ * errors and not by `requires` failure.
+ *
+ * `instruction` shapes the feedback preamble:
+ *   - omitted        → default "## Previous attempt failed verification..."
+ *   - string         → static text + verify error
+ *   - { auto: true } → LLM-generated diagnosis from default reflection prompt
+ *   - { reflect: s } → LLM-generated diagnosis from author-provided prompt
+ */
+export interface NodeRetry {
+    /** Maximum number of retry attempts after the initial run. Must be ≥ 1. */
+    max: number;
+    /** Preamble shape — see interface docs. */
+    instruction?: string | {
+        auto: true;
+    } | {
+        reflect: string;
+    };
+}
 /**
  * A single output assertion. Exactly one of `equals | in | matches` must be set.
  *
@@ -106,6 +150,10 @@ export interface Node {
     context?: NodeSources;
     /** Machine-checked post-conditions. Enforced by the executor after the LLM finishes. */
     verify?: NodeVerify;
+    /** Machine-checked pre-conditions. Enforced by the executor before the LLM runs. */
+    requires?: NodeRequires;
+    /** Node-local retry on verify failure (with optional autonomous reflection). */
+    retry?: NodeRetry;
 }
 /** An edge connecting two nodes */
 export interface Edge {
@@ -182,6 +230,12 @@ export type ExecutionEvent = {
     type: "node:progress";
     node: string;
     message: string;
+} | {
+    type: "node:retry";
+    node: string;
+    attempt: number;
+    reason: string;
+    preamble: string;
 } | {
     type: "route";
     from: string;
@@ -200,6 +254,8 @@ export interface TraceStep {
     status: "success" | "failed" | "skipped";
     /** 1-based iteration count (2 = second time this node ran) */
     iteration: number;
+    /** 0-indexed retry attempt for this iteration. Absent when no retry fired. */
+    retryAttempt?: number;
 }
 /** A routing decision between nodes */
 export interface TraceEdge {
@@ -245,6 +301,14 @@ export interface Claude {
             description: string;
         }[];
     }): Promise<string>;
+    /**
+     * Single-completion free-text query. No tools, no output schema.
+     * Used by the executor to generate retry strategies in autonomous reflection mode.
+     */
+    ask(opts: {
+        instruction: string;
+        context: Record<string, unknown>;
+    }): Promise<string>;
 }
 export interface McpServerConfig {
     type?: "stdio" | "http";

package/dist/verify.d.ts

@@ -8,6 +8,7 @@ export type Resolution = {
     reason: string;
 };
 export declare function resolvePath(data: unknown, path: string): Resolution;
+export declare function isErrorOutput(output: unknown): boolean;
 export declare function checkAnyToolCalled(required: string[], toolCalls: ToolCall[]): string | null;
 export declare function checkAllToolsCalled(required: string[], toolCalls: ToolCall[]): string | null;
 export declare function checkNoToolCalled(forbidden: string[], toolCalls: ToolCall[]): string | null;

package/dist/verify.js

@@ -72,7 +72,7 @@ export function resolvePath(data, path) {
 // A tool call "succeeded" when its output does not carry a non-null `error` field.
 // `{ error: null }` and `{ error: false }` are treated as success — many real
 // tools include the key with a null sentinel.
-function isErrorOutput(output) {
+export function isErrorOutput(output) {
     if (!output || typeof output !== "object")
         return false;
     const err = output.error;

package/dist/workflow-builder.test.js

@@ -73,6 +73,9 @@ describe("buildWorkflow", () => {
             async evaluate() {
                 return "";
             },
+            async ask() {
+                return "";
+            },
         };
         const opts = { claude: capturingClaude, skills: [mockSkill] };
         await buildWorkflow("Triage Sentry errors", opts);
@@ -108,6 +111,9 @@ describe("refineWorkflow", () => {
             async evaluate() {
                 return "";
             },
+            async ask() {
+                return "";
+            },
         };
         const opts = { claude: capturingClaude, skills: [mockSkill] };
         await refineWorkflow(validWorkflow, "Add a notification node", opts);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.76",
+  "version": "0.1.77",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"