@agentproto/workflow-runtime 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeremy André and agentproto contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,256 @@
+import { DriverHandle, ResolverContext } from '@agentproto/driver';
+import { ToolContext, ToolHandle } from '@agentproto/tool';
+import { WorkflowHandle } from '@agentproto/workflow';
+
+/**
+ * Typed step algebra for AIP-15 WORKFLOW execution.
+ *
+ * The AIP-15 manifest leaves the IO-threading (`step.inputs`, `map.over`,
+ * `branch.when`, `loop.while`) to a meta-validator — it never pins an
+ * expression language. Rather than invent a stringly DSL, this runtime
+ * expresses the AIP-16 IO seam as **typed selectors**: each step reads the
+ * run-scoped {@link Bindings} (workflow input + every prior step's output, plus
+ * the current item inside a `map`) through a plain `(bindings) => value`
+ * function. Authoring stays in TypeScript; compiling a declarative manifest's
+ * reference strings onto these selectors is a separable follow-up.
+ */
+
+/** The run-scoped data every selector reads from. */
+interface Bindings {
+    /** The workflow's invocation input. */
+    readonly input: unknown;
+    /** Each completed top-level step's output, keyed by step id. */
+    readonly steps: Readonly<Record<string, unknown>>;
+    /** Present inside a `map` body — the element being processed. */
+    readonly item?: unknown;
+    /** Present inside a `map` body — the element's index. */
+    readonly index?: number;
+}
+/** The AIP-16 IO seam: read a value out of the run bindings. */
+type Selector<T> = (bindings: Bindings) => T;
+/** Run a TOOL contract through the resolver; its output binds under `id`. */
+interface ToolStep<TInput = unknown, TOutput = unknown, TContext extends ToolContext = ToolContext> {
+    kind: "tool";
+    id: string;
+    tool: ToolHandle<TInput, TOutput, TContext>;
+    candidates: readonly DriverHandle[];
+    /** Derive the tool input from the run bindings. */
+    input: Selector<TInput>;
+    /** Derive the injected per-call context (live capabilities) from bindings. */
+    context?: Selector<TContext>;
+    resolverContext?: ResolverContext;
+    secrets?: Record<string, string>;
+}
+/** A pure in-run computation (combine / filter / shape) — no tool dispatch. */
+interface TransformStep {
+    kind: "transform";
+    id: string;
+    compute: Selector<unknown>;
+}
+/**
+ * Run a sub-step once per element of an array, optionally with bounded
+ * concurrency. The element + index are exposed to the body via `bindings.item`
+ * / `bindings.index`; the collected outputs bind under this step's id.
+ */
+interface MapStep {
+    kind: "map";
+    id: string;
+    over: Selector<readonly unknown[]>;
+    /** Max concurrent bodies (default 1 = sequential). */
+    parallelism?: number;
+    body: (item: unknown, index: number, bindings: Bindings) => RunStep;
+}
+/** Run one of two branches based on a predicate over the bindings. */
+interface BranchStep {
+    kind: "branch";
+    id: string;
+    cond: Selector<boolean>;
+    then: readonly RunStep[];
+    otherwise?: readonly RunStep[];
+}
+/** Repeat a body while a predicate holds, up to a hard iteration ceiling. */
+interface LoopStep {
+    kind: "loop";
+    id: string;
+    while: Selector<boolean>;
+    maxIterations: number;
+    body: readonly RunStep[];
+}
+/** Run several independent branches concurrently; outputs bind by branch id. */
+interface ParallelStep {
+    kind: "parallel";
+    id: string;
+    branches: readonly {
+        id: string;
+        steps: readonly RunStep[];
+    }[];
+}
+/**
+ * AIP-7 human-in-the-loop gate. The host's injected `approve` callback decides;
+ * the chosen `onApprove` / `onReject` sub-steps then run. Default (no callback)
+ * auto-approves. The step's own output is `{ approved }`.
+ */
+interface ApprovalStep {
+    kind: "approval";
+    id: string;
+    prompt: Selector<string>;
+    approvers?: readonly string[];
+    onApprove?: readonly RunStep[];
+    onReject?: readonly RunStep[];
+}
+/**
+ * Pause until an external event resumes the run. The host's injected `resume`
+ * callback supplies the resume payload (bound under this step's id). With no
+ * callback the run throws {@link WorkflowSuspendedError} — the durable-suspend
+ * path a host persists and re-enters later.
+ */
+interface SuspendStep {
+    kind: "suspend";
+    id: string;
+    on: readonly string[];
+    timeoutMs?: number;
+}
+/** Run an ordered list of steps as one unit; its output is the last step's. */
+interface GroupStep {
+    kind: "group";
+    id: string;
+    steps: readonly RunStep[];
+}
+/** Run a nested workflow with its own isolated bindings; its output binds here. */
+interface SubworkflowStep {
+    kind: "subworkflow";
+    id: string;
+    workflow: RuntimeWorkflow;
+    /** Input for the child (default: the parent's workflow input). */
+    input?: Selector<unknown>;
+}
+/**
+ * The element generics on `ToolStep` are erased to `any` so heterogeneous
+ * steps (different contracts, different input/output/context types) coexist in
+ * one `steps[]` array — per-step type safety is enforced where each step is
+ * authored, not at the collection level. Same contravariant-function-position
+ * constraint `@agentproto/driver`'s `implementations[]` works around (TS
+ * issue #21534); tightening the union to `ToolStep<unknown, …>` rejects a
+ * concrete `ToolStep<MarketSearchInput, …>` on the zod `ZodType<T>` variance.
+ */
+type RunStep = ToolStep<any, any, any> | TransformStep | MapStep | BranchStep | LoopStep | ParallelStep | ApprovalStep | SuspendStep | GroupStep | SubworkflowStep;
+interface RuntimeWorkflow {
+    id: string;
+    description?: string;
+    steps: readonly RunStep[];
+    /** Pick the run's final output (default: the last top-level step's output). */
+    output?: Selector<unknown>;
+}
+interface ApprovalRequest {
+    stepId: string;
+    prompt: string;
+    approvers: readonly string[];
+}
+interface ResumeRequest {
+    stepId: string;
+    on: readonly string[];
+}
+interface RunWorkflowArgs {
+    workflow: RuntimeWorkflow;
+    input?: unknown;
+    signal?: AbortSignal;
+    /** Decide an {@link ApprovalStep}. Default: auto-approve. */
+    approve?: (req: ApprovalRequest) => boolean | Promise<boolean>;
+    /** Supply a {@link SuspendStep}'s resume payload. Default: throw + suspend. */
+    resume?: (req: ResumeRequest) => unknown | Promise<unknown>;
+}
+interface WorkflowRunResult {
+    output: unknown;
+    bindings: Bindings;
+}
+
+/**
+ * The step-walker. Executes a {@link RuntimeWorkflow} top-to-bottom, threading
+ * each step's output into a run-scoped binding bag, and dispatching `tool`
+ * steps through `@agentproto/driver` `runTool` (resolve DRIVER → validate input
+ * + context → execute body → validate output). Composite steps (`map` /
+ * `branch` / `loop` / `parallel` / `approval` / `subworkflow`) recurse over the
+ * same bindings; `suspend` defers to the host's resume hook.
+ */
+
+/** Thrown by a `suspend` step when no host `resume` hook is provided. */
+declare class WorkflowSuspendedError extends Error {
+    readonly stepId: string;
+    readonly on: readonly string[];
+    constructor(stepId: string, on: readonly string[]);
+}
+declare function runWorkflow(args: RunWorkflowArgs): Promise<WorkflowRunResult>;
+
+/**
+ * Compile a declarative AIP-15 `WorkflowHandle` into a runnable
+ * {@link RuntimeWorkflow} for {@link runWorkflow}. This is the bridge that makes
+ * an authored WORKFLOW.md actually execute.
+ *
+ * AIP-15 leaves the IO seam (`step.inputs`, `map.over`, `loop.while`) to a
+ * meta-validator. This compiler pins a concrete, minimal **reference grammar**
+ * for it — the convention a manifest author writes:
+ *
+ *   - data refs:   `$input` · `$input.a.b` · `$steps.<id>` · `$steps.<id>.a`
+ *                  · `$item` · `$item.a` · `$index`   (`$$` escapes a literal `$`)
+ *   - `step.inputs`: a JSON object whose leaf strings may be refs (resolved
+ *                    recursively); non-`$` strings are literals
+ *   - `map.over`:    a ref to an array
+ *   - `loop.while` / approval prompt: `<ref> <op> <literal>` (`== != < <= > >=`)
+ *                    or a bare ref (truthiness)
+ *
+ * Scope: the **linear / structured subset** of AIP-15 — steps run in document
+ * order; `map`/`loop`/`parallel` nest their child step lists. Non-linear `next`
+ * gotos and goto-style `branch` routing are rejected with a clear diagnostic
+ * (hand-author a structured `BranchStep`, or nest). Compiling the full goto
+ * graph is a separable follow-up.
+ */
+
+interface CompileWorkflowOptions {
+    /** TOOL contracts by id — each `tool` step resolves its handle here. */
+    tools: ReadonlyMap<string, ToolHandle> | Record<string, ToolHandle>;
+    /** DRIVER candidates the resolver dispatches over for every tool step. */
+    candidates: readonly DriverHandle[];
+    /** Resolve a tool step's injected context (live capabilities) from bindings. */
+    contextFor?: (toolId: string, bindings: Bindings) => unknown;
+    /** Sub-workflows by id, for `subworkflow` steps. */
+    workflows?: ReadonlyMap<string, WorkflowHandle> | Record<string, WorkflowHandle>;
+}
+declare class WorkflowCompileError extends Error {
+    constructor(message: string);
+}
+/** Resolve a single `$…` reference string against the run bindings. */
+declare function resolveRef(ref: string, b: Bindings): unknown;
+/** Recursively resolve a value node: refs in strings, into arrays/objects. */
+declare function resolveValue(node: unknown, b: Bindings): unknown;
+/** Evaluate a `while`/`when` predicate string against the bindings. */
+declare function evalPredicate(expr: string, b: Bindings): boolean;
+declare function compileWorkflow(handle: WorkflowHandle, opts: CompileWorkflowOptions): RuntimeWorkflow;
+
+/**
+ * compileWorkflowManifest — the connective step between an authored
+ * `WORKFLOW.md` and a runnable workflow.
+ *
+ * AIP-15 ships every piece needed to run a declarative manifest except the
+ * seam that joins them: `parseWorkflowManifest` (md + frontmatter → manifest)
+ * and `workflowFromManifest` (manifest → `WorkflowHandle`) live in
+ * `@agentproto/workflow`; `compileWorkflow` (handle → `RuntimeWorkflow`) lives
+ * here. Without this chain an authored `WORKFLOW.md` parses and validates but
+ * never reaches the executor. This joins the three so a manifest source string
+ * compiles straight to a runnable workflow — no hand-built handle.
+ *
+ * Framework-pure: the caller owns reading the file off disk (this package does
+ * no I/O), and passes the source string in. The tool registry + driver
+ * candidates are injected via {@link CompileWorkflowOptions}, same as the
+ * hand-built path.
+ */
+
+/**
+ * Compile a `WORKFLOW.md` source string into a {@link RuntimeWorkflow} ready
+ * for `runWorkflow`. Parses + validates the frontmatter against the AIP-15
+ * schema, lifts it to a `WorkflowHandle`, then compiles its step graph against
+ * the injected tool registry. Throws on invalid frontmatter (the parser's
+ * diagnostic) or an unresolved tool / non-linear step (the compiler's).
+ */
+declare function compileWorkflowManifest(source: string, opts: CompileWorkflowOptions): RuntimeWorkflow;
+
+export { type ApprovalRequest, type ApprovalStep, type Bindings, type BranchStep, type CompileWorkflowOptions, type GroupStep, type LoopStep, type MapStep, type ParallelStep, type ResumeRequest, type RunStep, type RunWorkflowArgs, type RuntimeWorkflow, type Selector, type SubworkflowStep, type SuspendStep, type ToolStep, type TransformStep, WorkflowCompileError, type WorkflowRunResult, WorkflowSuspendedError, compileWorkflow, compileWorkflowManifest, evalPredicate, resolveRef, resolveValue, runWorkflow };

package/dist/index.mjs

@@ -0,0 +1,351 @@
+import { runTool } from '@agentproto/driver';
+import { parseWorkflowManifest, workflowFromManifest } from '@agentproto/workflow/manifest';
+
+/**
+ * @agentproto/workflow-runtime v0.1.0-alpha
+ * AIP-15 step-walker over @agentproto/driver runTool.
+ */
+
+var WorkflowSuspendedError = class extends Error {
+  constructor(stepId, on) {
+    super(
+      `workflow suspended at step '${stepId}' awaiting [${on.join(", ")}] \u2014 no resume hook supplied`
+    );
+    this.stepId = stepId;
+    this.on = on;
+    this.name = "WorkflowSuspendedError";
+  }
+  stepId;
+  on;
+};
+function view(state, item, index) {
+  return { input: state.input, steps: state.steps, item, index };
+}
+async function runSequence(steps, ctx, item, index) {
+  let last;
+  for (const s of steps) {
+    const out = await execStep(s, ctx, item, index);
+    ctx.state.steps[s.id] = out;
+    last = out;
+  }
+  return last;
+}
+async function execStep(step, ctx, item, index) {
+  const { state, signal } = ctx;
+  const b = view(state, item, index);
+  switch (step.kind) {
+    case "tool":
+      return runTool({
+        tool: step.tool,
+        candidates: step.candidates,
+        input: step.input(b),
+        context: step.context ? step.context(b) : void 0,
+        resolverContext: step.resolverContext,
+        secrets: step.secrets,
+        signal
+      });
+    case "transform":
+      return step.compute(b);
+    case "map": {
+      const arr = [...step.over(b)];
+      const parallelism = Math.max(1, step.parallelism ?? 1);
+      const results = new Array(arr.length);
+      for (let i = 0; i < arr.length; i += parallelism) {
+        const chunk = arr.slice(i, i + parallelism);
+        const outs = await Promise.all(
+          chunk.map((el, j) => {
+            const idx = i + j;
+            const inner = step.body(el, idx, view(state, el, idx));
+            return execStep(inner, ctx, el, idx);
+          })
+        );
+        for (let j = 0; j < outs.length; j++) results[i + j] = outs[j];
+      }
+      return results;
+    }
+    case "branch": {
+      const chosen = step.cond(b) ? step.then : step.otherwise ?? [];
+      return runSequence(chosen, ctx, item, index);
+    }
+    case "loop": {
+      let iterations = 0;
+      let last;
+      while (iterations < step.maxIterations && step.while(view(state, item, index))) {
+        last = await runSequence(step.body, ctx, item, index);
+        iterations++;
+      }
+      return last;
+    }
+    case "parallel": {
+      const outs = await Promise.all(
+        step.branches.map(
+          (br) => runSequence(br.steps, ctx, item, index).then((last) => ({
+            id: br.id,
+            last
+          }))
+        )
+      );
+      const record = {};
+      for (const { id, last } of outs) record[id] = last;
+      return record;
+    }
+    case "approval": {
+      const prompt = step.prompt(b);
+      const approvers = step.approvers ?? [];
+      const approved = ctx.approve ? await ctx.approve({ stepId: step.id, prompt, approvers }) : true;
+      const followups = approved ? step.onApprove ?? [] : step.onReject ?? [];
+      await runSequence(followups, ctx, item, index);
+      return { approved };
+    }
+    case "suspend": {
+      if (!ctx.resume) throw new WorkflowSuspendedError(step.id, step.on);
+      return ctx.resume({ stepId: step.id, on: step.on });
+    }
+    case "group":
+      return runSequence(step.steps, ctx, item, index);
+    case "subworkflow": {
+      const childInput = step.input ? step.input(b) : state.input;
+      const child = await runWorkflowInner(step.workflow, childInput, {
+        approve: ctx.approve,
+        resume: ctx.resume,
+        signal
+      });
+      return child.output;
+    }
+  }
+}
+async function runWorkflowInner(workflow, input, hooks) {
+  const state = { input, steps: {} };
+  const ctx = { state, ...hooks };
+  let lastId;
+  for (const step of workflow.steps) {
+    const out = await execStep(step, ctx, void 0, void 0);
+    state.steps[step.id] = out;
+    lastId = step.id;
+  }
+  const bindings = view(state);
+  const output = workflow.output ? workflow.output(bindings) : lastId !== void 0 ? state.steps[lastId] : void 0;
+  return { output, bindings };
+}
+async function runWorkflow(args) {
+  return runWorkflowInner(args.workflow, args.input, {
+    approve: args.approve,
+    resume: args.resume,
+    signal: args.signal
+  });
+}
+
+// src/compile-workflow.ts
+var WorkflowCompileError = class extends Error {
+  constructor(message) {
+    super(`compileWorkflow: ${message}`);
+    this.name = "WorkflowCompileError";
+  }
+};
+var get = (m, key) => m instanceof Map ? m.get(key) : m[key];
+function dig(value, path) {
+  let v = value;
+  for (const seg of path) {
+    if (v == null) return void 0;
+    v = v[seg];
+  }
+  return v;
+}
+function resolveRef(ref, b) {
+  if (ref === "$index") return b.index;
+  const m = ref.match(/^\$(input|item|steps)((?:\.[^.]+)*)$/);
+  if (!m) throw new WorkflowCompileError(`bad reference '${ref}'`);
+  const segs = m[2] ? m[2].slice(1).split(".") : [];
+  switch (m[1]) {
+    case "input":
+      return dig(b.input, segs);
+    case "item":
+      return dig(b.item, segs);
+    case "steps": {
+      const [stepId, ...rest] = segs;
+      if (!stepId) throw new WorkflowCompileError(`'$steps' needs a step id`);
+      return dig(b.steps[stepId], rest);
+    }
+  }
+}
+function resolveValue(node, b) {
+  if (typeof node === "string") {
+    if (node.startsWith("$$")) return node.slice(1);
+    if (node.startsWith("$")) return resolveRef(node, b);
+    return node;
+  }
+  if (Array.isArray(node)) return node.map((n) => resolveValue(n, b));
+  if (node && typeof node === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(node))
+      out[k] = resolveValue(v, b);
+    return out;
+  }
+  return node;
+}
+var COMPARATORS = {
+  "<": (a, c) => a < c,
+  "<=": (a, c) => a <= c,
+  ">": (a, c) => a > c,
+  ">=": (a, c) => a >= c
+};
+function literal(token, b) {
+  if (token.startsWith("$")) return resolveRef(token, b);
+  if (token === "true") return true;
+  if (token === "false") return false;
+  if (token === "null") return null;
+  if (/^-?\d+(\.\d+)?$/.test(token)) return Number(token);
+  return token.replace(/^['"]|['"]$/g, "");
+}
+function evalPredicate(expr, b) {
+  const m = expr.match(/^(.+?)\s*(==|!=|<=|>=|<|>)\s*(.+)$/);
+  if (!m) return Boolean(literal(expr.trim(), b));
+  const left = literal(m[1].trim(), b);
+  const right = literal(m[3].trim(), b);
+  switch (m[2]) {
+    case "==":
+      return left === right;
+    case "!=":
+      return left !== right;
+    default: {
+      const cmp = COMPARATORS[m[2]];
+      return cmp(Number(left), Number(right));
+    }
+  }
+}
+function normalizeToolId(ref) {
+  let s = ref.trim();
+  if (s.endsWith("/TOOL.md")) s = s.slice(0, -"/TOOL.md".length);
+  const slash = s.lastIndexOf("/");
+  return slash === -1 ? s : s.slice(slash + 1);
+}
+var f = (step, key) => step[key];
+function assertLinear(steps) {
+  steps.forEach((s, i) => {
+    const next = s.next;
+    const followingId = steps[i + 1]?.id;
+    if (next && next !== followingId) {
+      throw new WorkflowCompileError(
+        `step '${s.id}' has a non-linear next='${next}' \u2014 the structured-subset compiler only runs steps in document order. Hand-author a BranchStep or nest structurally.`
+      );
+    }
+  });
+}
+function compileWorkflow(handle, opts) {
+  const steps = handle.steps;
+  if (handle.start && handle.start !== steps[0]?.id) {
+    throw new WorkflowCompileError(
+      `start='${handle.start}' is not the first step \u2014 structured-subset runs in order`
+    );
+  }
+  assertLinear(steps);
+  const result = handle.result;
+  const output = result !== void 0 ? (b) => resolveValue(result, b) : void 0;
+  return {
+    id: handle.id,
+    description: handle.description,
+    steps: steps.map((s) => compileStep(s, opts)),
+    ...output ? { output } : {}
+  };
+}
+function compileStepList(steps, id, opts) {
+  assertLinear(steps);
+  if (steps.length === 1) return compileStep(steps[0], opts);
+  return { kind: "group", id, steps: steps.map((s) => compileStep(s, opts)) };
+}
+function compileStep(step, opts) {
+  const id = step.id;
+  switch (step.kind) {
+    case "tool": {
+      const ref = typeof step.tool === "string" ? step.tool : step.tool.entry;
+      const toolId = normalizeToolId(ref);
+      const tool = get(opts.tools, toolId);
+      if (!tool)
+        throw new WorkflowCompileError(`no tool registered for '${toolId}'`);
+      const inputs = f(step, "inputs") ?? {};
+      return {
+        kind: "tool",
+        id,
+        tool,
+        candidates: opts.candidates,
+        input: (b) => resolveValue(inputs, b),
+        context: opts.contextFor ? (b) => opts.contextFor(toolId, b) : void 0
+      };
+    }
+    case "map": {
+      const over = f(step, "over");
+      const inner = compileStepList(f(step, "steps"), `${id}__body`, opts);
+      return {
+        kind: "map",
+        id,
+        parallelism: f(step, "parallelism"),
+        over: (b) => resolveRef(over, b),
+        body: () => inner
+      };
+    }
+    case "loop": {
+      const whileExpr = f(step, "while");
+      return {
+        kind: "loop",
+        id,
+        maxIterations: f(step, "max_iterations"),
+        while: (b) => evalPredicate(whileExpr, b),
+        body: [compileStepList(f(step, "steps"), `${id}__body`, opts)]
+      };
+    }
+    case "parallel": {
+      const branches = f(step, "branches");
+      return {
+        kind: "parallel",
+        id,
+        branches: branches.map((br) => ({
+          id: br.id,
+          steps: [compileStepList(br.steps, `${id}__${br.id}`, opts)]
+        }))
+      };
+    }
+    case "approval": {
+      const prompt = f(step, "prompt");
+      const approvers = (f(step, "approvers") ?? []).map(
+        (a) => a.role ?? a.userId ?? String(a)
+      );
+      return {
+        kind: "approval",
+        id,
+        approvers,
+        prompt: (b) => String(resolveValue(prompt, b))
+      };
+    }
+    case "suspend": {
+      const resume = f(step, "resume");
+      return { kind: "suspend", id, on: resume.on, timeoutMs: resume.timeout_ms };
+    }
+    case "subworkflow": {
+      const wfId = f(step, "workflow");
+      const child = opts.workflows ? get(opts.workflows, wfId) : void 0;
+      if (!child)
+        throw new WorkflowCompileError(
+          `subworkflow '${wfId}' not found \u2014 pass it in opts.workflows`
+        );
+      const compiledChild = compileWorkflow(child, opts);
+      return { kind: "subworkflow", id, workflow: compiledChild };
+    }
+    case "branch":
+      throw new WorkflowCompileError(
+        `goto-style 'branch' (step '${id}') is unsupported in the structured subset \u2014 hand-author a structured BranchStep, or nest.`
+      );
+    default:
+      throw new WorkflowCompileError(
+        `unsupported step kind '${step.kind}' (step '${id}')`
+      );
+  }
+}
+function compileWorkflowManifest(source, opts) {
+  const manifest = parseWorkflowManifest(source);
+  const handle = workflowFromManifest(manifest);
+  return compileWorkflow(handle, opts);
+}
+
+export { WorkflowCompileError, WorkflowSuspendedError, compileWorkflow, compileWorkflowManifest, evalPredicate, resolveRef, resolveValue, runWorkflow };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/run-workflow.ts","../src/compile-workflow.ts","../src/load-workflow.ts"],"names":[],"mappings":"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","file":"index.mjs","sourcesContent":["/**\n * The step-walker. Executes a {@link RuntimeWorkflow} top-to-bottom, threading\n * each step's output into a run-scoped binding bag, and dispatching `tool`\n * steps through `@agentproto/driver` `runTool` (resolve DRIVER → validate input\n * + context → execute body → validate output). Composite steps (`map` /\n * `branch` / `loop` / `parallel` / `approval` / `subworkflow`) recurse over the\n * same bindings; `suspend` defers to the host's resume hook.\n */\n\nimport { runTool } from \"@agentproto/driver\"\nimport type {\n  Bindings,\n  RunStep,\n  RunWorkflowArgs,\n  RuntimeWorkflow,\n  WorkflowRunResult,\n} from \"./types.js\"\n\n/** Thrown by a `suspend` step when no host `resume` hook is provided. */\nexport class WorkflowSuspendedError extends Error {\n  constructor(\n    readonly stepId: string,\n    readonly on: readonly string[],\n  ) {\n    super(\n      `workflow suspended at step '${stepId}' awaiting [${on.join(\", \")}] — ` +\n        `no resume hook supplied`,\n    )\n    this.name = \"WorkflowSuspendedError\"\n  }\n}\n\ninterface RunState {\n  readonly input: unknown\n  readonly steps: Record<string, unknown>\n}\n\ninterface RunCtx {\n  readonly state: RunState\n  readonly approve?: RunWorkflowArgs[\"approve\"]\n  readonly resume?: RunWorkflowArgs[\"resume\"]\n  readonly signal?: AbortSignal\n}\n\nfunction view(state: RunState, item?: unknown, index?: number): Bindings {\n  return { input: state.input, steps: state.steps, item, index }\n}\n\n/** Run an ordered list of steps, binding each output under its id; return last. */\nasync function runSequence(\n  steps: readonly RunStep[],\n  ctx: RunCtx,\n  item: unknown,\n  index: number | undefined,\n): Promise<unknown> {\n  let last: unknown\n  for (const s of steps) {\n    const out = await execStep(s, ctx, item, index)\n    ctx.state.steps[s.id] = out\n    last = out\n  }\n  return last\n}\n\nasync function execStep(\n  step: RunStep,\n  ctx: RunCtx,\n  item: unknown,\n  index: number | undefined,\n): Promise<unknown> {\n  const { state, signal } = ctx\n  const b = view(state, item, index)\n  switch (step.kind) {\n    case \"tool\":\n      return runTool({\n        tool: step.tool,\n        candidates: step.candidates,\n        input: step.input(b),\n        context: step.context ? step.context(b) : undefined,\n        resolverContext: step.resolverContext,\n        secrets: step.secrets,\n        signal,\n      })\n\n    case \"transform\":\n      return step.compute(b)\n\n    case \"map\": {\n      const arr = [...step.over(b)]\n      const parallelism = Math.max(1, step.parallelism ?? 1)\n      const results: unknown[] = new Array(arr.length)\n      for (let i = 0; i < arr.length; i += parallelism) {\n        const chunk = arr.slice(i, i + parallelism)\n        const outs = await Promise.all(\n          chunk.map((el, j) => {\n            const idx = i + j\n            const inner = step.body(el, idx, view(state, el, idx))\n            return execStep(inner, ctx, el, idx)\n          }),\n        )\n        for (let j = 0; j < outs.length; j++) results[i + j] = outs[j]\n      }\n      return results\n    }\n\n    case \"branch\": {\n      const chosen = step.cond(b) ? step.then : (step.otherwise ?? [])\n      return runSequence(chosen, ctx, item, index)\n    }\n\n    case \"loop\": {\n      let iterations = 0\n      let last: unknown\n      while (\n        iterations < step.maxIterations &&\n        step.while(view(state, item, index))\n      ) {\n        last = await runSequence(step.body, ctx, item, index)\n        iterations++\n      }\n      return last\n    }\n\n    case \"parallel\": {\n      const outs = await Promise.all(\n        step.branches.map((br) =>\n          runSequence(br.steps, ctx, item, index).then((last) => ({\n            id: br.id,\n            last,\n          })),\n        ),\n      )\n      const record: Record<string, unknown> = {}\n      for (const { id, last } of outs) record[id] = last\n      return record\n    }\n\n    case \"approval\": {\n      const prompt = step.prompt(b)\n      const approvers = step.approvers ?? []\n      const approved = ctx.approve\n        ? await ctx.approve({ stepId: step.id, prompt, approvers })\n        : true\n      const followups = approved\n        ? (step.onApprove ?? [])\n        : (step.onReject ?? [])\n      await runSequence(followups, ctx, item, index)\n      return { approved }\n    }\n\n    case \"suspend\": {\n      if (!ctx.resume) throw new WorkflowSuspendedError(step.id, step.on)\n      return ctx.resume({ stepId: step.id, on: step.on })\n    }\n\n    case \"group\":\n      return runSequence(step.steps, ctx, item, index)\n\n    case \"subworkflow\": {\n      const childInput = step.input ? step.input(b) : state.input\n      const child = await runWorkflowInner(step.workflow, childInput, {\n        approve: ctx.approve,\n        resume: ctx.resume,\n        signal,\n      })\n      return child.output\n    }\n  }\n}\n\nasync function runWorkflowInner(\n  workflow: RuntimeWorkflow,\n  input: unknown,\n  hooks: Pick<RunCtx, \"approve\" | \"resume\" | \"signal\">,\n): Promise<WorkflowRunResult> {\n  const state: RunState = { input, steps: {} }\n  const ctx: RunCtx = { state, ...hooks }\n  let lastId: string | undefined\n  for (const step of workflow.steps) {\n    const out = await execStep(step, ctx, undefined, undefined)\n    state.steps[step.id] = out\n    lastId = step.id\n  }\n  const bindings = view(state)\n  const output = workflow.output\n    ? workflow.output(bindings)\n    : lastId !== undefined\n      ? state.steps[lastId]\n      : undefined\n  return { output, bindings }\n}\n\nexport async function runWorkflow(\n  args: RunWorkflowArgs,\n): Promise<WorkflowRunResult> {\n  return runWorkflowInner(args.workflow, args.input, {\n    approve: args.approve,\n    resume: args.resume,\n    signal: args.signal,\n  })\n}\n","/**\n * Compile a declarative AIP-15 `WorkflowHandle` into a runnable\n * {@link RuntimeWorkflow} for {@link runWorkflow}. This is the bridge that makes\n * an authored WORKFLOW.md actually execute.\n *\n * AIP-15 leaves the IO seam (`step.inputs`, `map.over`, `loop.while`) to a\n * meta-validator. This compiler pins a concrete, minimal **reference grammar**\n * for it — the convention a manifest author writes:\n *\n *   - data refs:   `$input` · `$input.a.b` · `$steps.<id>` · `$steps.<id>.a`\n *                  · `$item` · `$item.a` · `$index`   (`$$` escapes a literal `$`)\n *   - `step.inputs`: a JSON object whose leaf strings may be refs (resolved\n *                    recursively); non-`$` strings are literals\n *   - `map.over`:    a ref to an array\n *   - `loop.while` / approval prompt: `<ref> <op> <literal>` (`== != < <= > >=`)\n *                    or a bare ref (truthiness)\n *\n * Scope: the **linear / structured subset** of AIP-15 — steps run in document\n * order; `map`/`loop`/`parallel` nest their child step lists. Non-linear `next`\n * gotos and goto-style `branch` routing are rejected with a clear diagnostic\n * (hand-author a structured `BranchStep`, or nest). Compiling the full goto\n * graph is a separable follow-up.\n */\n\nimport type { WorkflowHandle } from \"@agentproto/workflow\"\nimport type { DriverHandle } from \"@agentproto/driver\"\nimport type { ToolHandle } from \"@agentproto/tool\"\nimport type { Bindings, RunStep, RuntimeWorkflow } from \"./types.js\"\n\nexport interface CompileWorkflowOptions {\n  /** TOOL contracts by id — each `tool` step resolves its handle here. */\n  tools: ReadonlyMap<string, ToolHandle> | Record<string, ToolHandle>\n  /** DRIVER candidates the resolver dispatches over for every tool step. */\n  candidates: readonly DriverHandle[]\n  /** Resolve a tool step's injected context (live capabilities) from bindings. */\n  contextFor?: (toolId: string, bindings: Bindings) => unknown\n  /** Sub-workflows by id, for `subworkflow` steps. */\n  workflows?:\n    | ReadonlyMap<string, WorkflowHandle>\n    | Record<string, WorkflowHandle>\n}\n\nexport class WorkflowCompileError extends Error {\n  constructor(message: string) {\n    super(`compileWorkflow: ${message}`)\n    this.name = \"WorkflowCompileError\"\n  }\n}\n\n// ── reference + predicate resolution (the AIP-16 IO seam) ────────────\n\nconst get = <T>(\n  m: ReadonlyMap<string, T> | Record<string, T>,\n  key: string,\n): T | undefined =>\n  m instanceof Map ? m.get(key) : (m as Record<string, T>)[key]\n\nfunction dig(value: unknown, path: readonly string[]): unknown {\n  let v = value\n  for (const seg of path) {\n    if (v == null) return undefined\n    v = (v as Record<string, unknown>)[seg]\n  }\n  return v\n}\n\n/** Resolve a single `$…` reference string against the run bindings. */\nexport function resolveRef(ref: string, b: Bindings): unknown {\n  if (ref === \"$index\") return b.index\n  const m = ref.match(/^\\$(input|item|steps)((?:\\.[^.]+)*)$/)\n  if (!m) throw new WorkflowCompileError(`bad reference '${ref}'`)\n  const segs = m[2] ? m[2].slice(1).split(\".\") : []\n  switch (m[1]) {\n    case \"input\":\n      return dig(b.input, segs)\n    case \"item\":\n      return dig(b.item, segs)\n    case \"steps\": {\n      const [stepId, ...rest] = segs\n      if (!stepId) throw new WorkflowCompileError(`'$steps' needs a step id`)\n      return dig(b.steps[stepId], rest)\n    }\n  }\n}\n\n/** Recursively resolve a value node: refs in strings, into arrays/objects. */\nexport function resolveValue(node: unknown, b: Bindings): unknown {\n  if (typeof node === \"string\") {\n    if (node.startsWith(\"$$\")) return node.slice(1) // $$ → literal $\n    if (node.startsWith(\"$\")) return resolveRef(node, b)\n    return node\n  }\n  if (Array.isArray(node)) return node.map((n) => resolveValue(n, b))\n  if (node && typeof node === \"object\") {\n    const out: Record<string, unknown> = {}\n    for (const [k, v] of Object.entries(node as Record<string, unknown>))\n      out[k] = resolveValue(v, b)\n    return out\n  }\n  return node\n}\n\nconst COMPARATORS: Record<string, (a: number, b: number) => boolean> = {\n  \"<\": (a, c) => a < c,\n  \"<=\": (a, c) => a <= c,\n  \">\": (a, c) => a > c,\n  \">=\": (a, c) => a >= c,\n}\n\nfunction literal(token: string, b: Bindings): unknown {\n  if (token.startsWith(\"$\")) return resolveRef(token, b)\n  if (token === \"true\") return true\n  if (token === \"false\") return false\n  if (token === \"null\") return null\n  if (/^-?\\d+(\\.\\d+)?$/.test(token)) return Number(token)\n  return token.replace(/^['\"]|['\"]$/g, \"\")\n}\n\n/** Evaluate a `while`/`when` predicate string against the bindings. */\nexport function evalPredicate(expr: string, b: Bindings): boolean {\n  const m = expr.match(/^(.+?)\\s*(==|!=|<=|>=|<|>)\\s*(.+)$/)\n  if (!m) return Boolean(literal(expr.trim(), b)) // bare ref → truthiness\n  const left = literal(m[1]!.trim(), b)\n  const right = literal(m[3]!.trim(), b)\n  switch (m[2]) {\n    case \"==\":\n      return left === right\n    case \"!=\":\n      return left !== right\n    default: {\n      const cmp = COMPARATORS[m[2]!]!\n      return cmp(Number(left), Number(right))\n    }\n  }\n}\n\n// ── step compilation ─────────────────────────────────────────────────\n\n/** AIP step ids may be paths/refs; the runtime key is the last segment. */\nfunction normalizeToolId(ref: string): string {\n  let s = ref.trim()\n  if (s.endsWith(\"/TOOL.md\")) s = s.slice(0, -\"/TOOL.md\".length)\n  const slash = s.lastIndexOf(\"/\")\n  return slash === -1 ? s : s.slice(slash + 1)\n}\n\n// AIP step frontmatter leaves IO fields as opaque `{}`; read them dynamically.\nconst f = <T>(step: object, key: string): T =>\n  (step as Record<string, unknown>)[key] as T\n\nfunction assertLinear(steps: readonly { id: string; kind: string; next?: string }[]): void {\n  steps.forEach((s, i) => {\n    const next = (s as { next?: string }).next\n    const followingId = steps[i + 1]?.id\n    if (next && next !== followingId) {\n      throw new WorkflowCompileError(\n        `step '${s.id}' has a non-linear next='${next}' — the structured-subset ` +\n          `compiler only runs steps in document order. Hand-author a BranchStep ` +\n          `or nest structurally.`,\n      )\n    }\n  })\n}\n\nexport function compileWorkflow(\n  handle: WorkflowHandle,\n  opts: CompileWorkflowOptions,\n): RuntimeWorkflow {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const steps = handle.steps as unknown as any[]\n  if (handle.start && handle.start !== steps[0]?.id) {\n    throw new WorkflowCompileError(\n      `start='${handle.start}' is not the first step — structured-subset runs in order`,\n    )\n  }\n  assertLinear(steps)\n  // `result` is the optional output value-expression (AIP-15): map it through\n  // the same ref grammar as a step's inputs. Absent ⇒ no output selector, so\n  // runWorkflow falls back to the final step's result.\n  const result = (handle as { result?: unknown }).result\n  const output =\n    result !== undefined ? (b: Bindings) => resolveValue(result, b) : undefined\n  return {\n    id: handle.id,\n    description: handle.description,\n    steps: steps.map((s) => compileStep(s, opts)),\n    ...(output ? { output } : {}),\n  }\n}\n\nfunction compileStepList(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  steps: any[],\n  id: string,\n  opts: CompileWorkflowOptions,\n): RunStep {\n  assertLinear(steps)\n  if (steps.length === 1) return compileStep(steps[0], opts)\n  return { kind: \"group\", id, steps: steps.map((s) => compileStep(s, opts)) }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction compileStep(step: any, opts: CompileWorkflowOptions): RunStep {\n  const id: string = step.id\n  switch (step.kind) {\n    case \"tool\": {\n      const ref = typeof step.tool === \"string\" ? step.tool : step.tool.entry\n      const toolId = normalizeToolId(ref)\n      const tool = get(opts.tools, toolId)\n      if (!tool)\n        throw new WorkflowCompileError(`no tool registered for '${toolId}'`)\n      const inputs = f<unknown>(step, \"inputs\") ?? {}\n      return {\n        kind: \"tool\",\n        id,\n        tool,\n        candidates: opts.candidates,\n        input: (b) => resolveValue(inputs, b),\n        context: opts.contextFor\n          ? (b) => opts.contextFor!(toolId, b)\n          : undefined,\n      }\n    }\n\n    case \"map\": {\n      const over = f<string>(step, \"over\")\n      const inner = compileStepList(f(step, \"steps\"), `${id}__body`, opts)\n      return {\n        kind: \"map\",\n        id,\n        parallelism: f<number | undefined>(step, \"parallelism\"),\n        over: (b) => resolveRef(over, b) as readonly unknown[],\n        body: () => inner,\n      }\n    }\n\n    case \"loop\": {\n      const whileExpr = f<string>(step, \"while\")\n      return {\n        kind: \"loop\",\n        id,\n        maxIterations: f<number>(step, \"max_iterations\"),\n        while: (b) => evalPredicate(whileExpr, b),\n        body: [compileStepList(f(step, \"steps\"), `${id}__body`, opts)],\n      }\n    }\n\n    case \"parallel\": {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const branches = f<any[]>(step, \"branches\")\n      return {\n        kind: \"parallel\",\n        id,\n        branches: branches.map((br) => ({\n          id: br.id,\n          steps: [compileStepList(br.steps, `${id}__${br.id}`, opts)],\n        })),\n      }\n    }\n\n    case \"approval\": {\n      const prompt = f<string>(step, \"prompt\")\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const approvers = (f<any[]>(step, \"approvers\") ?? []).map(\n        (a) => a.role ?? a.userId ?? String(a),\n      )\n      return {\n        kind: \"approval\",\n        id,\n        approvers,\n        prompt: (b) => String(resolveValue(prompt, b)),\n      }\n    }\n\n    case \"suspend\": {\n      const resume = f<{ on: string[]; timeout_ms?: number }>(step, \"resume\")\n      return { kind: \"suspend\", id, on: resume.on, timeoutMs: resume.timeout_ms }\n    }\n\n    case \"subworkflow\": {\n      const wfId = f<string>(step, \"workflow\")\n      const child = opts.workflows ? get(opts.workflows, wfId) : undefined\n      if (!child)\n        throw new WorkflowCompileError(\n          `subworkflow '${wfId}' not found — pass it in opts.workflows`,\n        )\n      const compiledChild = compileWorkflow(child, opts)\n      return { kind: \"subworkflow\", id, workflow: compiledChild }\n    }\n\n    case \"branch\":\n      throw new WorkflowCompileError(\n        `goto-style 'branch' (step '${id}') is unsupported in the structured ` +\n          `subset — hand-author a structured BranchStep, or nest.`,\n      )\n\n    default:\n      throw new WorkflowCompileError(\n        `unsupported step kind '${step.kind}' (step '${id}')`,\n      )\n  }\n}\n","/**\n * compileWorkflowManifest — the connective step between an authored\n * `WORKFLOW.md` and a runnable workflow.\n *\n * AIP-15 ships every piece needed to run a declarative manifest except the\n * seam that joins them: `parseWorkflowManifest` (md + frontmatter → manifest)\n * and `workflowFromManifest` (manifest → `WorkflowHandle`) live in\n * `@agentproto/workflow`; `compileWorkflow` (handle → `RuntimeWorkflow`) lives\n * here. Without this chain an authored `WORKFLOW.md` parses and validates but\n * never reaches the executor. This joins the three so a manifest source string\n * compiles straight to a runnable workflow — no hand-built handle.\n *\n * Framework-pure: the caller owns reading the file off disk (this package does\n * no I/O), and passes the source string in. The tool registry + driver\n * candidates are injected via {@link CompileWorkflowOptions}, same as the\n * hand-built path.\n */\n\nimport {\n  parseWorkflowManifest,\n  workflowFromManifest,\n} from \"@agentproto/workflow/manifest\"\n\nimport { compileWorkflow } from \"./compile-workflow.js\"\nimport type { CompileWorkflowOptions } from \"./compile-workflow.js\"\nimport type { RuntimeWorkflow } from \"./types.js\"\n\n/**\n * Compile a `WORKFLOW.md` source string into a {@link RuntimeWorkflow} ready\n * for `runWorkflow`. Parses + validates the frontmatter against the AIP-15\n * schema, lifts it to a `WorkflowHandle`, then compiles its step graph against\n * the injected tool registry. Throws on invalid frontmatter (the parser's\n * diagnostic) or an unresolved tool / non-linear step (the compiler's).\n */\nexport function compileWorkflowManifest(\n  source: string,\n  opts: CompileWorkflowOptions,\n): RuntimeWorkflow {\n  const manifest = parseWorkflowManifest(source)\n  const handle = workflowFromManifest(manifest)\n  return compileWorkflow(handle, opts)\n}\n"]}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@agentproto/workflow-runtime",
+  "version": "0.1.1",
+  "description": "Reference step-walker for AIP-15 WORKFLOW composition: executes a typed step graph (tool / map / branch / loop / transform) over @agentproto/driver runTool, threading each step's output into a run-scoped binding bag (the AIP-16 IO seam, expressed as typed selectors). The missing executor that makes 'composition = config' runnable.",
+  "keywords": [
+    "agentproto",
+    "aip-15",
+    "workflow",
+    "runtime",
+    "step-walker",
+    "orchestration",
+    "open-standard",
+    "agentic"
+  ],
+  "homepage": "https://agentproto.sh/docs/aip-15",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentproto/ts"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@agentproto/driver": "0.1.1",
+    "@agentproto/tool": "0.1.1",
+    "@agentproto/workflow": "0.1.0-alpha.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "zod": "^4.4.3",
+    "@agentproto/tooling": "0.1.0-alpha.0"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}