@sweny-ai/core 0.1.61 → 0.1.63

package/dist/schema.js

@@ -63,11 +63,26 @@ export const skillZ = z
     .refine((s) => s.tools.length > 0 || s.instruction || s.mcp, {
     message: "Skill must provide at least one of: tools, instruction, or mcp",
 });
+/**
+ * NodeSources: either an array of Sources (additive — inherits cascade)
+ * or an object `{ only?: boolean, sources: Source[] }` where `only: true`
+ * blocks the cascade for that field.
+ */
+export const nodeSourcesZ = z.union([
+    z.array(sourceZ),
+    z.object({
+        only: z.boolean().optional(),
+        sources: z.array(sourceZ),
+    }),
+]);
 export const nodeZ = z.object({
     name: z.string().min(1),
     instruction: sourceZ,
     skills: z.array(z.string()).default([]),
     output: jsonSchemaZ.optional(),
+    max_turns: z.number().int().min(1).optional(),
+    rules: nodeSourcesZ.optional(),
+    context: nodeSourcesZ.optional(),
 });
 export const edgeZ = z.object({
     from: z.string().min(1),
@@ -83,6 +98,8 @@ export const workflowZ = z.object({
     edges: z.array(edgeZ),
     entry: z.string().min(1),
     skills: z.record(skillDefinitionZ).default({}),
+    rules: z.array(sourceZ).optional(),
+    context: z.array(sourceZ).optional(),
 });
 /** Parse + validate a raw object as a Workflow. Throws on invalid input. */
 export function parseWorkflow(raw) {
@@ -268,12 +285,38 @@ export const workflowJsonSchema = {
     type: "object",
     required: ["id", "name", "nodes", "edges", "entry"],
     additionalProperties: false,
-    $defs: { Source: sourceJsonSchema },
+    $defs: {
+        Source: sourceJsonSchema,
+        NodeSources: {
+            oneOf: [
+                { type: "array", items: { $ref: "#/$defs/Source" } },
+                {
+                    type: "object",
+                    required: ["sources"],
+                    additionalProperties: false,
+                    properties: {
+                        only: { type: "boolean" },
+                        sources: { type: "array", items: { $ref: "#/$defs/Source" } },
+                    },
+                },
+            ],
+        },
+    },
     properties: {
         id: { type: "string", minLength: 1 },
         name: { type: "string", minLength: 1 },
         description: { type: "string" },
         entry: { type: "string", minLength: 1, description: "ID of the entry node" },
+        rules: {
+            type: "array",
+            items: { $ref: "#/$defs/Source" },
+            description: "Directives prepended to every node's instruction.",
+        },
+        context: {
+            type: "array",
+            items: { $ref: "#/$defs/Source" },
+            description: "Background knowledge prepended to every node's instruction.",
+        },
         nodes: {
             type: "object",
             additionalProperties: {
@@ -292,6 +335,19 @@ export const workflowJsonSchema = {
                         type: "object",
                         description: "Optional JSON Schema for structured output",
                     },
+                    max_turns: {
+                        type: "integer",
+                        minimum: 1,
+                        description: "Max AI model turns for this node. When absent, the executor's default applies.",
+                    },
+                    rules: {
+                        $ref: "#/$defs/NodeSources",
+                        description: "Per-node rules. Additive by default; set { only: true } to block cascade.",
+                    },
+                    context: {
+                        $ref: "#/$defs/NodeSources",
+                        description: "Per-node context. Additive by default; set { only: true } to block cascade.",
+                    },
                 },
             },
         },

package/dist/types.d.ts

@@ -37,6 +37,18 @@ export interface Skill {
     /** External MCP server definition wired for nodes referencing this skill. */
     mcp?: McpServerConfig;
 }
+/**
+ * Per-node rules or context.
+ *
+ * - Array form (additive): inherits workflow/runtime sources AND adds these.
+ * - Object form: when `only: true`, blocks the cascade for this field and
+ *   uses only `sources`. When `only` is absent/false, behaves like the
+ *   array form.
+ */
+export type NodeSources = _Source[] | {
+    only?: boolean;
+    sources: _Source[];
+};
 /** A node in the workflow DAG */
 export interface Node {
     /** Human-readable name */
@@ -47,6 +59,12 @@ export interface Node {
     skills: string[];
     /** Optional structured output schema */
     output?: JSONSchema;
+    /** Max AI model turns for this node. When absent, the executor's default applies. */
+    max_turns?: number;
+    /** Per-node directives. Additive by default; set `{ only: true, sources: [...] }` to block cascade. */
+    rules?: NodeSources;
+    /** Per-node background knowledge. Additive by default; set `{ only: true, sources: [...] }` to block cascade. */
+    context?: NodeSources;
 }
 /** An edge connecting two nodes */
 export interface Edge {
@@ -66,6 +84,10 @@ export interface Workflow {
     edges: Edge[];
     entry: string;
     skills?: Record<string, SkillDefinition>;
+    /** Directives prepended to every node's instruction. Cascade into per-node rules. */
+    rules?: _Source[];
+    /** Background knowledge prepended to every node's instruction. Cascade into per-node context. */
+    context?: _Source[];
 }
 /**
  * Inline skill definition in a workflow's `skills` block.
@@ -170,6 +192,8 @@ export interface Claude {
         outputSchema?: JSONSchema;
         /** Called with status messages while Claude is working (tool name, etc.) */
         onProgress?: (message: string) => void;
+        /** Per-node turn limit. Overrides the client default when set. */
+        maxTurns?: number;
     }): Promise<NodeResult>;
     /** Evaluate a routing condition — pick one of N choices */
     evaluate(opts: {

package/package.json

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