@sweny-ai/core 0.1.102 → 0.1.103

package/dist/executor.js

@@ -17,7 +17,15 @@ import { resolveSources } from "./source-resolver.js";
 import { evaluateAll, aggregateEval } from "./eval/index.js";
 import { evaluateRequires } from "./requires.js";
 import { buildRetryPreamble } from "./retry.js";
+import { resolveExecutionModel } from "./model.js";
 import { buildToolAliases } from "./skills/index.js";
+/**
+ * Default workflow-level step budget. Counts total node executions across the
+ * whole run (loop iterations included). Generous enough for legitimate deep
+ * workflows with controlled cycles, tight enough to terminate a runaway loop
+ * before it burns meaningful model spend.
+ */
+export const DEFAULT_MAX_STEPS = 200;
 /**
  * Execute a workflow from entry to completion.
  *
@@ -31,11 +39,13 @@ export async function execute(workflow, input, options) {
     // Inline skills (instruction/mcp only) become Skill objects with empty tools/config.
     // The caller's skill map takes precedence — inline skills only fill gaps.
     const skills = mergeInlineSkills(options.skills, workflow.skills);
-    const config = resolveConfig(skills, options.config);
+    const config = resolveConfig(skills, options.config, options.env ?? process.env);
     const logger = options.logger ?? consoleLogger;
     const results = new Map();
     const edgeCounts = new Map(); // "from→to" → times followed
     const nodeRunCounts = new Map(); // node → times executed
+    const maxSteps = options.max_steps ?? DEFAULT_MAX_STEPS;
+    let stepCount = 0; // total node executions across the run (loop iterations included)
     const trace = { steps: [], edges: [], sources: {} };
     validate(workflow, skills);
     // Build an eval-time alias table from the loaded skills. Each skill owns
@@ -86,6 +96,17 @@ export async function execute(workflow, input, options) {
         const node = workflow.nodes[currentId];
         if (!node)
             throw new Error(`Unknown node: "${currentId}"`);
+        // Workflow-level hard cap. Per-edge max_iterations bounds individual
+        // back-edges, but a self-loop (or LLM route) with no max_iterations is
+        // otherwise unbounded. This budget terminates the run loudly instead of
+        // hanging CI / the action and burning model spend.
+        stepCount++;
+        if (stepCount > maxSteps) {
+            throw new Error(`step budget exceeded: workflow '${workflow.id}' ran ${stepCount} steps (max_steps: ${maxSteps}). ` +
+                `This usually means an unbounded cycle, e.g. a back-edge with no 'max_iterations' or a route that keeps ` +
+                `looping. Add 'max_iterations' to the offending edge or raise 'max_steps' if the workflow legitimately ` +
+                `needs more steps.`);
+        }
         const iteration = (nodeRunCounts.get(currentId) ?? 0) + 1;
         nodeRunCounts.set(currentId, iteration);
         const resolvedInstruction = resolvedSources[`nodes.${currentId}.instruction`].content;
@@ -159,6 +180,9 @@ export async function execute(workflow, input, options) {
         let result;
         let currentInstruction = instruction;
         const retry = node.retry;
+        // Per-node execution model: node.model ?? workflow.model. When undefined,
+        // claude.run falls back to its own client default (then Claude Code's).
+        const nodeModel = resolveExecutionModel(node, workflow);
         while (true) {
             result = await claude.run({
                 instruction: currentInstruction,
@@ -167,6 +191,7 @@ export async function execute(workflow, input, options) {
                 outputSchema: node.output,
                 maxTurns: node.max_turns,
                 disallowedTools: node.disallowed_tools,
+                model: nodeModel,
                 onProgress: (message) => {
                     safeObserve(observer, { type: "node:progress", node: currentId, message }, logger);
                 },
@@ -187,25 +212,35 @@ export async function execute(workflow, input, options) {
             // validation. Type mismatches, formats, additionalProperties, etc.
             // stay the workflow author's problem and don't have the same
             // routing-correctness blast radius.
+            // A missing required field is a contract violation handled on the same
+            // footing as an eval failure: an otherwise-recoverable one-off omission
+            // should self-heal on a second attempt when the node has `retry`
+            // configured. We synthesize an eval-shaped failure so the retry preamble
+            // and trace bookkeeping below treat it identically. When no retry is
+            // configured (or the budget is exhausted), it still hard-fails the node.
             const missingRequired = findMissingRequiredFields(result.data, node.output);
+            let outcome;
             if (missingRequired.length > 0) {
                 const msg = `output schema violation: required field(s) missing from emitted data: ${missingRequired.join(", ")}`;
-                result.status = "failed";
-                result.data = { ...(result.data ?? {}), error: msg };
-                logger.warn(`  ${msg}`, { node: currentId });
-                break;
+                const failure = { name: "output_required", kind: "value", pass: false, reasoning: msg };
+                outcome = { pass: false, error: msg, failures: [failure] };
+                // Still record the synthesized failure as the node's eval result so
+                // observers and downstream context see the contract violation.
+                result.evals = [failure];
+            }
+            else {
+                const evalResults = await evaluateAll(node.eval, result, {
+                    aliases: toolAliases,
+                    claude,
+                    node,
+                    workflow,
+                });
+                result.evals = evalResults;
+                outcome = aggregateEval(evalResults, node.eval_policy ?? "all_pass");
             }
-            const evalResults = await evaluateAll(node.eval, result, {
-                aliases: toolAliases,
-                claude,
-                node,
-                workflow,
-            });
-            result.evals = evalResults;
-            const outcome = aggregateEval(evalResults, node.eval_policy ?? "all_pass");
             if (outcome.pass)
                 break;
-            // Apply eval failure to the result.
+            // Apply the failure to the result.
             result.status = "failed";
             result.data = { ...result.data, error: outcome.error };
             if (!retry || attempt >= retry.max) {
@@ -225,6 +260,7 @@ export async function execute(workflow, input, options) {
                 claude,
                 logger,
                 context,
+                model: nodeModel,
             });
             currentInstruction = `${preamble}\n\n---\n\n${instruction}`;
             safeObserve(observer, { type: "node:retry", node: currentId, attempt: attempt + 1, reason: outcome.error ?? "eval failed", preamble }, logger);
@@ -562,13 +598,18 @@ function resolveSkillInstructions(skillIds, skills) {
 /**
  * Resolve config values: check explicit overrides first, then env vars.
  * Throws if a required field is missing.
+ *
+ * `env` is the environment map to read `field.env` from. Callers thread
+ * `options.env ?? process.env` so an explicit env map is honored consistently
+ * with Source resolution (which reads the same map). Defaults to
+ * `process.env` when omitted.
  */
-function resolveConfig(skills, overrides) {
+function resolveConfig(skills, overrides, env = process.env) {
     const config = {};
     const missing = [];
     for (const skill of skills.values()) {
         for (const [key, field] of Object.entries(skill.config)) {
-            const value = overrides?.[key] ?? (field.env ? process.env[field.env] : undefined);
+            const value = overrides?.[key] ?? (field.env ? env[field.env] : undefined);
             if (value) {
                 config[key] = value;
             }
@@ -691,14 +732,36 @@ async function resolveNext(workflow, current, results, input, claude, observer,
         context,
         choices,
     });
-    // Validate that Claude returned a valid target
+    // Validate that Claude returned a valid target.
     const validTargets = new Set(outEdges.map((e) => e.to));
-    const resolved = validTargets.has(chosen) ? chosen : (defaultEdge?.to ?? outEdges[0].to); // fall back to default or first edge
+    if (!validTargets.has(chosen)) {
+        // The evaluator returned a target that is not a live out-edge. If there's
+        // an explicit default (unconditional) edge, take it as the documented
+        // fallback. Otherwise this is a hard error: silently jumping to
+        // `outEdges[0]` (often the loop-back edge) launders garbage model output
+        // into a plausible-looking route and, combined with an unbounded cycle,
+        // produces an infinite loop. Stop loudly instead.
+        if (!defaultEdge) {
+            logger?.warn(`  route eval: evaluator returned invalid target '${chosen}' for node '${current}' and there is no ` +
+                `default (unconditional) edge; terminating this branch. Valid targets: ${[...validTargets].join(", ")}`, { node: current, chosen, validTargets: [...validTargets] });
+            safeObserve(observer, {
+                type: "route",
+                from: current,
+                to: "(end)",
+                reason: `invalid route target '${chosen}' with no default edge`,
+            }, logger);
+            return null;
+        }
+    }
+    const resolved = validTargets.has(chosen) ? chosen : defaultEdge.to;
     // Track edge usage for max_iterations
     if (edgeCounts) {
         const key = `${current}→${resolved}`;
         edgeCounts.set(key, (edgeCounts.get(key) ?? 0) + 1);
     }
+    // Report the matched choice's description. The `?? "default"` fallback now
+    // only fires when a default edge genuinely exists (the no-default invalid
+    // case returned null above), so it can no longer mislabel a garbage route.
     safeObserve(observer, {
         type: "route",
         from: current,

package/dist/index.d.ts

@@ -21,18 +21,22 @@
  * })
  * ```
  */
-export type { Skill, SkillCategory, SkillDefinition, Tool, ToolContext, ConfigField, JSONSchema, Workflow, Node, Edge, NodeResult, ToolCall, ExecutionEvent, Observer, Claude, Logger, TraceStep, TraceEdge, ExecutionTrace, ExecutionResult, Source, ResolvedSource, SourceKind, SourceResolutionMap, WorkflowInputs, WorkflowInputField, WorkflowInputType, InputValidationError, InputValidationResult, } from "./types.js";
+export type { Skill, SkillCategory, SkillDefinition, Tool, ToolContext, ConfigField, JSONSchema, Workflow, Node, Edge, NodeResult, ToolCall, ExecutionEvent, Observer, Claude, Logger, TraceStep, TraceEdge, ExecutionTrace, ExecutionResult, Source, ResolvedSource, SourceKind, SourceResolutionMap, WorkflowInputs, WorkflowInputField, WorkflowInputType, InputValidationError, InputValidationResult, Evaluator, EvaluatorRule, EvalResult, EvaluatorKind, NodeRequires, NodeRetry, OutputMatch, NodeSources, EvalPolicy, RequiresOnFail, McpTransport, WorkflowType, SkillHarnessKey, } from "./types.js";
 export { WORKFLOW_INPUT_TYPES } from "./types.js";
+export { EVALUATOR_KINDS, EVAL_POLICIES, REQUIRES_ON_FAIL, MCP_TRANSPORTS, SKILL_CATEGORIES, SKILL_HARNESSES, SKILL_ID_PATTERN, SKILL_ID_MAX_LENGTH, isValidSkillId, } from "./types.js";
 export { consoleLogger } from "./types.js";
 export { execute } from "./executor.js";
 export type { ExecuteOptions } from "./executor.js";
-export { ClaudeClient } from "./claude.js";
-export type { ClaudeClientOptions } from "./claude.js";
+export { ClaudeClient, resolveAuthEnv } from "./claude.js";
+export type { ClaudeClientOptions, SwenyAuthMode, ResolveAuthEnvOpts } from "./claude.js";
+export { resolveExecutionModel } from "./model.js";
 export { github, linear, slack, sentry, datadog, notification, supabase, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredBuiltinSkills, validateWorkflowSkills, } from "./skills/index.js";
 export type { SkillValidationResult } from "./skills/index.js";
 export { loadCustomSkills, discoverSkills, configuredSkills } from "./skills/custom-loader.js";
-export { workflowZ, nodeZ, edgeZ, skillZ, mcpServerConfigZ, skillDefinitionZ, sourceZ, workflowInputsZ, parseWorkflow, validateWorkflow, workflowJsonSchema, } from "./schema.js";
+export { workflowZ, nodeZ, edgeZ, skillZ, mcpServerConfigZ, skillDefinitionZ, sourceZ, workflowInputsZ, parseWorkflow, validateWorkflow, workflowJsonSchema, skillJsonSchema, } from "./schema.js";
 export type { WorkflowError } from "./schema.js";
+export { loadAndValidateWorkflow, validateParsed } from "./loader.js";
+export type { LoaderResult, LoaderError, LoaderOptions } from "./loader.js";
 export { validateRuntimeInput, summarizeInputShape } from "./inputs.js";
 export { buildAutoMcpServers, buildSkillMcpServers, buildProviderContext } from "./mcp.js";
 export type { ProviderContextOptions, SkillMcpOptions } from "./mcp.js";

package/dist/index.js

@@ -22,17 +22,25 @@
  * ```
  */
 export { WORKFLOW_INPUT_TYPES } from "./types.js";
+// Runtime enum constants + skill-id helpers
+export { EVALUATOR_KINDS, EVAL_POLICIES, REQUIRES_ON_FAIL, MCP_TRANSPORTS, SKILL_CATEGORIES, SKILL_HARNESSES, SKILL_ID_PATTERN, SKILL_ID_MAX_LENGTH, isValidSkillId, } from "./types.js";
 export { consoleLogger } from "./types.js";
 // Executor
 export { execute } from "./executor.js";
 // Claude client
-export { ClaudeClient } from "./claude.js";
+export { ClaudeClient, resolveAuthEnv } from "./claude.js";
+// Execution model resolution
+export { resolveExecutionModel } from "./model.js";
 // Skills
 export { github, linear, slack, sentry, datadog, notification, supabase, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredBuiltinSkills, validateWorkflowSkills, } from "./skills/index.js";
 // Node-only skill discovery (filesystem-based)
 export { loadCustomSkills, discoverSkills, configuredSkills } from "./skills/custom-loader.js";
 // Schema & validation
-export { workflowZ, nodeZ, edgeZ, skillZ, mcpServerConfigZ, skillDefinitionZ, sourceZ, workflowInputsZ, parseWorkflow, validateWorkflow, workflowJsonSchema, } from "./schema.js";
+export { workflowZ, nodeZ, edgeZ, skillZ, mcpServerConfigZ, skillDefinitionZ, sourceZ, workflowInputsZ, parseWorkflow, validateWorkflow, workflowJsonSchema, skillJsonSchema, } from "./schema.js";
+// Loader — canonical read → parse → structural-validate pipeline (the path
+// the CLI uses for `workflow run`, `workflow validate`, and `publish`).
+// Node-only: loader.ts imports `node:fs`, so this is NOT mirrored in browser.ts.
+export { loadAndValidateWorkflow, validateParsed } from "./loader.js";
 // Workflow input validation
 export { validateRuntimeInput, summarizeInputShape } from "./inputs.js";
 // MCP auto-injection

package/dist/inputs.js

@@ -161,7 +161,16 @@ export function validateRuntimeInput(declared, raw) {
     // and the cascade `rules`/`context` mechanism inject extra keys into
     // the input bag. The declaration narrows the contract for documented
     // fields without locking down the whole object.
+    //
+    // Prototype-pollution guard: `raw` is `unknown` and callers (Studio,
+    // programmatic scripts) may hand us hand-built objects, or `JSON.parse`
+    // output containing an enumerable own `__proto__` key. Writing such a
+    // key with `out[k] = v` would reassign the result's prototype. Skip the
+    // three dangerous keys so untrusted input can never touch the prototype
+    // chain. `out` stays a normal object literal for downstream consumers.
     for (const [k, v] of Object.entries(provided)) {
+        if (isUnsafeKey(k))
+            continue;
         if (!Object.prototype.hasOwnProperty.call(declared, k)) {
             out[k] = v;
         }
@@ -195,6 +204,15 @@ export function summarizeInputShape(declared, resolved) {
     return shape;
 }
 // ─── Internals ──────────────────────────────────────────────────
+/**
+ * Keys that must never be copied from untrusted input onto a plain object,
+ * because assigning them mutates the prototype chain rather than adding an
+ * own property. `JSON.parse('{"__proto__":{...}}')` produces an enumerable
+ * own `__proto__` key that `Object.entries` surfaces.
+ */
+function isUnsafeKey(key) {
+    return key === "__proto__" || key === "constructor" || key === "prototype";
+}
 function checkValueType(value, type) {
     switch (type) {
         case "string":

package/dist/loader.js

@@ -13,7 +13,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { parse as parseYaml } from "yaml";
 import { ZodError } from "zod";
-import { workflowZ, validateWorkflow } from "./schema.js";
+import { workflowZ, validateWorkflow, preflightLegacyVerify } from "./schema.js";
 /**
  * Load a workflow YAML or JSON file, parse with the canonical Zod schema,
  * and run structural validation. All three phases contribute to `errors`.
@@ -47,6 +47,20 @@ export function validateParsed(raw, options = {}) {
         const kind = raw === null ? "null" : Array.isArray(raw) ? "array" : typeof raw;
         return { ok: false, errors: [{ message: `Expected a workflow object, got ${kind}`, code: "SCHEMA" }] };
     }
+    // Detect legacy `verify:` blocks (renamed to `eval:` in v0.2.0) before the
+    // Zod parse. workflowZ is intentionally non-strict at the top level, so a
+    // top-level `verify:` would be silently STRIPPED instead of surfacing the
+    // migration message. parseWorkflow runs this preflight already; validateParsed
+    // (the entrypoint for loadAndValidateWorkflow / Studio import) must too. The
+    // loader contract is "return errors, do not throw", so map the throw to a
+    // SCHEMA LoaderError rather than letting it propagate.
+    try {
+        preflightLegacyVerify(raw);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, errors: [{ message: msg, code: "SCHEMA" }] };
+    }
     let parsed;
     try {
         parsed = workflowZ.parse(raw);

package/dist/model.d.ts

@@ -0,0 +1,11 @@
+import type { Node, Workflow } from "./types.js";
+/**
+ * Resolve the execution model for a node: `node.model ?? workflow.model`.
+ *
+ * Returns `undefined` when neither is set. The client default (if any) is
+ * applied one layer down, inside `ClaudeClient.run` (`model ?? this.model`),
+ * so the full three-layer cascade is node → workflow → client default →
+ * Claude Code default. Callers SHOULD pass `undefined` through to `run`
+ * rather than substituting a hardcoded model.
+ */
+export declare function resolveExecutionModel(node: Node | undefined, workflow: Workflow | undefined): string | undefined;

package/dist/model.js

@@ -0,0 +1,19 @@
+// ─── Execution model resolution ─────────────────────────────────────
+//
+// Mirrors the judge-model cascade in eval/index.ts, but for the model that
+// executes a node (not the model that evaluates it). Unlike the judge
+// resolver, there is NO package-level default: when no layer specifies a
+// model, this returns undefined so the executor emits no SDK `model` option
+// and Claude Code's own default applies.
+/**
+ * Resolve the execution model for a node: `node.model ?? workflow.model`.
+ *
+ * Returns `undefined` when neither is set. The client default (if any) is
+ * applied one layer down, inside `ClaudeClient.run` (`model ?? this.model`),
+ * so the full three-layer cascade is node → workflow → client default →
+ * Claude Code default. Callers SHOULD pass `undefined` through to `run`
+ * rather than substituting a hardcoded model.
+ */
+export function resolveExecutionModel(node, workflow) {
+    return node?.model ?? workflow?.model;
+}

package/dist/retry.d.ts

@@ -12,6 +12,11 @@ export interface BuildRetryPreambleOptions {
     claude: Claude;
     logger: Logger;
     context: Record<string, unknown>;
+    /**
+     * Per-node execution model. The reflection reasons about this node, so it
+     * runs on the node's model. When undefined, the client default applies.
+     */
+    model?: string;
 }
 /**
  * Build the retry preamble for a single retry attempt.

package/dist/retry.js

@@ -21,7 +21,7 @@ const DEFAULT_PREAMBLE_HEADER = "## Previous attempt failed evaluation";
  * default static preamble and logs a warning.
  */
 export async function buildRetryPreamble(opts) {
-    const { retry, evalFailures, toolCalls, nodeInstruction, claude, logger, context } = opts;
+    const { retry, evalFailures, toolCalls, nodeInstruction, claude, logger, context, model } = opts;
     const failureList = formatEvalFailures(evalFailures);
     const inst = retry.instruction;
     if (typeof inst === "string") {
@@ -31,7 +31,7 @@ export async function buildRetryPreamble(opts) {
         const reflectPrompt = "reflect" in inst && typeof inst.reflect === "string" ? inst.reflect : DEFAULT_REFLECTION_PROMPT;
         const askInstruction = buildReflectionPrompt(reflectPrompt, nodeInstruction, failureList, toolCalls);
         try {
-            const diagnosis = await claude.ask({ instruction: askInstruction, context });
+            const diagnosis = await claude.ask({ instruction: askInstruction, context, model });
             const trimmed = diagnosis.trim();
             if (trimmed.length > 0) {
                 return `## Reflection on previous attempt\n\n${trimmed}\n\n${DEFAULT_PREAMBLE_HEADER}\n\n${failureList}`;