@theokit/sdk 2.25.0 → 2.27.0

package/dist/types/workflow.d.ts

@@ -101,6 +101,19 @@ export interface StepContext {
     };
     /** Pause the workflow; resume via `Workflow.resume({...})`. */
     readonly suspend: (payload?: unknown) => Promise<never>;
+    /**
+     * SE29 — the workflow's shared state (from `WorkflowOptions.initialState`,
+     * mutated by {@link setState}), visible to every subsequent step in the run.
+     * `undefined` when no `initialState`/`setState` has run. Persisted across
+     * suspend/resume.
+     */
+    readonly state: unknown;
+    /**
+     * SE29 — update the shared state for subsequent steps. Validated against
+     * `WorkflowOptions.stateSchema` when set (a mismatch throws
+     * {@link WorkflowStateError}, which fails the step/run — Rule 8).
+     */
+    readonly setState: (next: unknown) => void;
 }
 export interface StepResult {
     readonly stepId: string;
@@ -128,15 +141,57 @@ export interface WorkflowRun<TOutput = unknown> {
     readonly stepResults: ReadonlyArray<StepResult>;
 }
 export interface WorkflowSnapshot {
-    readonly _schemaVersion: 1;
+    /** v1 = pre-SE29 (no `state`); v2 = SE29 (carries `state`). Resume reads both. */
+    readonly _schemaVersion: 1 | 2;
     readonly runId: string;
     readonly workflowName: string;
     readonly currentStepId: string;
     readonly suspendedPayload?: unknown;
     readonly stepResults: ReadonlyArray<StepResult>;
     readonly accumulatedInput: unknown;
+    /** SE29 — shared state captured at suspend (v2). Absent on a v1 snapshot. */
+    readonly state?: unknown;
     readonly suspendedAt: number;
 }
+/**
+ * SE28 — a step-level workflow event emitted by `Workflow.stream()` as top-level
+ * steps run. Coarse-grained (one event per top-level step; nested
+ * parallel/branch/foreach emit as their single wrapping step), distinct from the
+ * token-delta agent stream. Discriminate on `type`.
+ *
+ * @public
+ */
+export type WorkflowEvent = {
+    readonly type: "step_started";
+    readonly stepId: string;
+} | {
+    readonly type: "step_completed";
+    readonly stepId: string;
+    readonly output: unknown;
+} | {
+    readonly type: "step_failed";
+    readonly stepId: string;
+    readonly error: {
+        readonly name: string;
+        readonly message: string;
+    };
+} | {
+    readonly type: "workflow_suspended";
+    readonly stepId: string;
+} | {
+    readonly type: "workflow_completed";
+};
+/**
+ * SE28 — the async iterator returned by `Workflow.stream()`. Yields
+ * {@link WorkflowEvent}s in execution order; `result` resolves to the same
+ * terminal {@link WorkflowRun} the `run()` path returns (the authoritative
+ * outcome — the stream ends when the run terminates).
+ *
+ * @public
+ */
+export type WorkflowStream<TOutput = unknown> = AsyncIterableIterator<WorkflowEvent> & {
+    readonly result: Promise<WorkflowRun<TOutput>>;
+};
 export interface WorkflowPersistenceOptions {
     readonly backend: "memory" | "json";
     /** Required for `backend: "json"`. */
@@ -145,6 +200,34 @@ export interface WorkflowPersistenceOptions {
 export interface WorkflowOptions {
     readonly name: string;
     readonly persistence?: WorkflowPersistenceOptions;
+    /**
+     * SE27 — Zod schema for the WHOLE workflow's input. When set, `run(input)`
+     * validates `input` BEFORE step 1; a mismatch yields `status: "failed"` with a
+     * typed {@link WorkflowInputError} in `error` (fail-fast, no step runs, no
+     * silent coerce). Absent ⇒ no whole-workflow input validation (unchanged).
+     */
+    readonly inputSchema?: ZodType;
+    /**
+     * SE27 — Zod schema for the workflow's final output. When set, the terminal
+     * `completed` output is validated before `WorkflowRun.output` is populated; a
+     * mismatch yields `status: "failed"` with a typed {@link WorkflowOutputError}.
+     * Only validated on the `completed` path (suspended/failed runs skip it).
+     */
+    readonly outputSchema?: ZodType;
+    /**
+     * SE29 — Zod schema for the workflow's shared state (see `StepContext.state` /
+     * `setState`). When set, `initialState` and every `setState(next)` are
+     * validated against it (a mismatch throws {@link WorkflowStateError}). When
+     * `initialState` is absent, `state` starts as `undefined` and validation fires
+     * on the first `setState` call.
+     */
+    readonly stateSchema?: ZodType;
+    /**
+     * SE29 — the initial shared state, seeded onto `StepContext.state` before
+     * step 1. Validated against `stateSchema` when both are set. Persisted across
+     * suspend/resume.
+     */
+    readonly initialState?: unknown;
     /** Internal — minted at `.commit()`. Not user-facing. */
     readonly workflowId?: string;
 }
@@ -179,6 +262,56 @@ export declare class WorkflowDuplicateStepIdError extends Error {
     readonly name = "WorkflowDuplicateStepIdError";
     constructor(stepId: string);
 }
+/**
+ * SE27 — the whole-workflow `inputSchema` rejected `run(input)` (before step 1).
+ * `detail` is a pre-formatted issues summary (a string, NOT Zod's `ZodIssue[]`).
+ */
+export declare class WorkflowInputError extends Error {
+    readonly workflowName: string;
+    readonly detail: string;
+    readonly name = "WorkflowInputError";
+    constructor(workflowName: string, detail: string);
+}
+/**
+ * SE27 — the whole-workflow `outputSchema` rejected the final output (on `completed`).
+ * `detail` is a pre-formatted issues summary (a string, NOT Zod's `ZodIssue[]`).
+ */
+export declare class WorkflowOutputError extends Error {
+    readonly workflowName: string;
+    readonly detail: string;
+    readonly name = "WorkflowOutputError";
+    constructor(workflowName: string, detail: string);
+}
+/**
+ * SE29 — `WorkflowOptions.stateSchema` rejected an `initialState` or a
+ * `setState(next)` call. `detail` is a pre-formatted issues summary.
+ */
+export declare class WorkflowStateError extends Error {
+    readonly workflowName: string;
+    readonly detail: string;
+    readonly name = "WorkflowStateError";
+    constructor(workflowName: string, detail: string);
+}
+/**
+ * SE30 — a nested workflow (via `workflowStep`) did not `complete`. A nested
+ * `suspended` is NOT resumable in v1 (resume continues AFTER the step, so the
+ * child would be skipped) — restructure with a top-level suspend. A nested
+ * `failed`/`cancelled` fails the parent step with the child's error attached.
+ */
+export declare class WorkflowNestedError extends Error {
+    readonly stepId: string;
+    readonly childName: string;
+    readonly childStatus: Exclude<WorkflowRun["status"], "completed">;
+    readonly childError?: {
+        name: string;
+        message: string;
+    } | undefined;
+    readonly name = "WorkflowNestedError";
+    constructor(stepId: string, childName: string, childStatus: Exclude<WorkflowRun["status"], "completed">, childError?: {
+        name: string;
+        message: string;
+    } | undefined);
+}
 export declare class WorkflowAlreadyRunningError extends Error {
     readonly workflowName: string;
     readonly runId: string;

package/dist/workflow.cjs

@@ -213,7 +213,7 @@ var init_errors = __esm({
 });
 
 // src/types/workflow.ts
-exports.WorkflowDuplicateStepIdError = void 0; exports.WorkflowAlreadyRunningError = void 0; exports.WorkflowSnapshotNotFoundError = void 0; exports.WorkflowMaxIterationsExceededError = void 0; exports.WorkflowNotSerializableError = void 0; exports.WorkflowResumeStepNotFoundError = void 0; exports.WorkflowParallelError = void 0; exports.WorkflowCompensateNotImplementedError = void 0;
+exports.WorkflowDuplicateStepIdError = void 0; exports.WorkflowInputError = void 0; exports.WorkflowOutputError = void 0; exports.WorkflowStateError = void 0; exports.WorkflowNestedError = void 0; exports.WorkflowAlreadyRunningError = void 0; exports.WorkflowSnapshotNotFoundError = void 0; exports.WorkflowMaxIterationsExceededError = void 0; exports.WorkflowNotSerializableError = void 0; exports.WorkflowResumeStepNotFoundError = void 0; exports.WorkflowParallelError = void 0; exports.WorkflowCompensateNotImplementedError = void 0;
 var init_workflow = __esm({
   "src/types/workflow.ts"() {
     exports.WorkflowDuplicateStepIdError = class extends Error {
@@ -224,6 +224,57 @@ var init_workflow = __esm({
       stepId;
       name = "WorkflowDuplicateStepIdError";
     };
+    exports.WorkflowInputError = class extends Error {
+      constructor(workflowName, detail) {
+        super(`Workflow "${workflowName}" input failed schema validation: ${detail}`);
+        this.workflowName = workflowName;
+        this.detail = detail;
+      }
+      workflowName;
+      detail;
+      name = "WorkflowInputError";
+    };
+    exports.WorkflowOutputError = class extends Error {
+      constructor(workflowName, detail) {
+        super(`Workflow "${workflowName}" output failed schema validation: ${detail}`);
+        this.workflowName = workflowName;
+        this.detail = detail;
+      }
+      workflowName;
+      detail;
+      name = "WorkflowOutputError";
+    };
+    exports.WorkflowStateError = class extends Error {
+      constructor(workflowName, detail) {
+        super(`Workflow "${workflowName}" state failed schema validation: ${detail}`);
+        this.workflowName = workflowName;
+        this.detail = detail;
+      }
+      workflowName;
+      detail;
+      name = "WorkflowStateError";
+    };
+    exports.WorkflowNestedError = class extends Error {
+      constructor(stepId, childName, childStatus, childError) {
+        super(
+          `Nested workflow "${childName}" (step "${stepId}") ended with status "${childStatus}"${childStatus === "suspended" ? " \u2014 nested suspend/resume is not supported in v1 (use a top-level suspend)" : ""}${childError ? `: ${childError.name}: ${childError.message}` : ""}`,
+          // Reconstruct a synthetic Error from the serialized child-error shape so
+          // debuggers surface the nested cause chain — the original Error instance is
+          // lost at the WorkflowRun serialization boundary, so this is the best
+          // achievable without changing the run protocol.
+          childError ? { cause: Object.assign(new Error(childError.message), { name: childError.name }) } : void 0
+        );
+        this.stepId = stepId;
+        this.childName = childName;
+        this.childStatus = childStatus;
+        this.childError = childError;
+      }
+      stepId;
+      childName;
+      childStatus;
+      childError;
+      name = "WorkflowNestedError";
+    };
     exports.WorkflowAlreadyRunningError = class extends Error {
       constructor(workflowName, runId) {
         super(`Workflow "${workflowName}" run "${runId}" already in-flight.`);
@@ -472,7 +523,7 @@ var init_snapshot_store = __esm({
 });
 
 // src/internal/workflow/ctx.ts
-function makeStepContext(runId, signal) {
+function makeStepContext(runId, signal, state2) {
   return {
     runId,
     signal,
@@ -483,7 +534,13 @@ function makeStepContext(runId, signal) {
     },
     suspend: async (payload) => {
       throw new WorkflowSuspendedSentinel(payload);
-    }
+    },
+    // SE29 — read reflects the current shared state; write goes through the
+    // controller (which validates against `stateSchema`).
+    get state() {
+      return state2.getState();
+    },
+    setState: (next) => state2.setState(next)
   };
 }
 function emit(level, runId, msg, attrs) {
@@ -536,6 +593,57 @@ var init_error_shape = __esm({
   }
 });
 
+// src/internal/workflow/executor-helpers.ts
+function assembleRun(params) {
+  return {
+    id: params.runId,
+    name: params.name,
+    status: params.status,
+    startedAt: params.startedAt,
+    endedAt: Date.now(),
+    stepResults: params.stepResults,
+    ...params.output !== void 0 ? { output: params.output } : {},
+    ...params.error !== void 0 ? { error: params.error } : {}
+  };
+}
+function abortRun(name, runId, startedAt, stepResults, signal) {
+  return assembleRun({
+    runId,
+    name,
+    status: "cancelled",
+    stepResults,
+    startedAt,
+    error: { name: "AbortError", message: String(signal.reason ?? "Aborted") }
+  });
+}
+function validateWorkflowSchema(schema, value) {
+  if (schema === void 0) return void 0;
+  let parsed;
+  try {
+    parsed = schema.safeParse(value);
+  } catch {
+    return "schema uses async refinements, which whole-workflow validation does not support (use a synchronous Zod schema)";
+  }
+  if (parsed.success) return void 0;
+  return parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+}
+function makeStateController(options, initial) {
+  let current = initial;
+  return {
+    getState: () => current,
+    setState: (next) => {
+      const issues = validateWorkflowSchema(options.stateSchema, next);
+      if (issues !== void 0) throw new exports.WorkflowStateError(options.name, issues);
+      current = next;
+    }
+  };
+}
+var init_executor_helpers = __esm({
+  "src/internal/workflow/executor-helpers.ts"() {
+    init_workflow();
+  }
+});
+
 // src/internal/workflow/run-id.ts
 function mintRunId() {
   return `wfr-${globalThis.crypto.randomUUID().replace(/-/g, "").slice(0, 8)}`;
@@ -1273,6 +1381,8 @@ async function handleSuspend(err, ctx) {
       suspendedPayload: err.payload,
       stepResults: ctx.stepResults,
       accumulatedInput: ctx.acc,
+      state: ctx.stepCtx.state,
+      // SE29 — capture the shared state at suspend
       options: ctx.options
     });
   } catch (snapErr) {
@@ -1324,7 +1434,7 @@ async function runOneStep(args) {
     result = await dispatchStep(args.step, args.acc, args.ctx, args.options, args.stepResults);
   } catch (err) {
     if (err instanceof WorkflowSuspendedSentinel) {
-      const outcome = await handleSuspend(err, { ...args, stepSpan });
+      const outcome = await handleSuspend(err, { ...args, stepSpan, stepCtx: args.ctx });
       return { kind: "terminal", run: outcome.run };
     }
     result = {
@@ -1341,22 +1451,42 @@ async function runOneStep(args) {
   stepSpan.end();
   return { kind: "ok", result };
 }
-function abortRun(name, runId, startedAt, stepResults, signal) {
-  return assembleRun({
-    runId,
-    name,
-    status: "cancelled",
-    stepResults,
-    startedAt,
-    error: { name: "AbortError", message: String(signal.reason ?? "Aborted") }
-  });
+function handleStepOutcome(outcome, step, loop, onStepEvent) {
+  if (outcome.kind === "terminal") {
+    if (outcome.run.status === "suspended") {
+      onStepEvent?.({ type: "workflow_suspended", stepId: step.id });
+    }
+    return { terminal: outcome.run };
+  }
+  loop.stepResults.push(outcome.result);
+  if (outcome.result.status === "failed") {
+    onStepEvent?.({
+      type: "step_failed",
+      stepId: step.id,
+      error: outcome.result.error ?? { name: "WorkflowStepError", message: "step failed" }
+    });
+    return {
+      terminal: assembleRun({
+        runId: loop.runId,
+        name: loop.name,
+        status: "failed",
+        stepResults: loop.stepResults,
+        startedAt: loop.startedAt,
+        error: outcome.result.error
+      })
+    };
+  }
+  onStepEvent?.({ type: "step_completed", stepId: step.id, output: outcome.result.output });
+  return { acc: outcome.result.output };
 }
 async function runStepsLoop(params) {
-  const { options, steps, ctx, runId, startedAt, signal } = params;
+  const { options, steps, ctx, runId, startedAt, signal, onStepEvent } = params;
   const stepResults = [...params.initialStepResults ?? []];
+  const loop = { stepResults, runId, name: options.name, startedAt };
   let acc = params.input;
   for (const step of steps) {
     if (signal.aborted) return abortRun(options.name, runId, startedAt, stepResults, signal);
+    onStepEvent?.({ type: "step_started", stepId: step.id });
     const outcome = await runOneStep({
       step,
       acc,
@@ -1367,20 +1497,22 @@ async function runStepsLoop(params) {
       name: options.name,
       startedAt
     });
-    if (outcome.kind === "terminal") return outcome.run;
-    stepResults.push(outcome.result);
-    if (outcome.result.status === "failed") {
-      return assembleRun({
-        runId,
-        name: options.name,
-        status: "failed",
-        stepResults,
-        startedAt,
-        error: outcome.result.error
-      });
-    }
-    acc = outcome.result.output;
+    const handled = handleStepOutcome(outcome, step, loop, onStepEvent);
+    if ("terminal" in handled) return handled.terminal;
+    acc = handled.acc;
   }
+  const outputIssues = validateWorkflowSchema(options.outputSchema, acc);
+  if (outputIssues !== void 0) {
+    return assembleRun({
+      runId,
+      name: options.name,
+      status: "failed",
+      stepResults,
+      startedAt,
+      error: errToShape(new exports.WorkflowOutputError(options.name, outputIssues))
+    });
+  }
+  onStepEvent?.({ type: "workflow_completed" });
   return assembleRun({
     runId,
     name: options.name,
@@ -1403,8 +1535,33 @@ async function executeWorkflow(options, steps, input, runOpts) {
     runSpan.end();
     return abortRun(options.name, runId, startedAt, [], signal);
   }
-  const ctx = makeStepContext(runId, signal);
+  const internal = runOpts;
+  const seededState = internal?.restoredState !== void 0 ? internal.restoredState : options.initialState;
+  const stateController = makeStateController(options, seededState);
+  const ctx = makeStepContext(runId, signal, stateController);
   try {
+    const inputIssues = validateWorkflowSchema(options.inputSchema, input);
+    if (inputIssues !== void 0) {
+      return assembleRun({
+        runId,
+        name: options.name,
+        status: "failed",
+        stepResults: [],
+        startedAt,
+        error: errToShape(new exports.WorkflowInputError(options.name, inputIssues))
+      });
+    }
+    const stateIssues = seededState !== void 0 ? validateWorkflowSchema(options.stateSchema, seededState) : void 0;
+    if (stateIssues !== void 0) {
+      return assembleRun({
+        runId,
+        name: options.name,
+        status: "failed",
+        stepResults: [],
+        startedAt,
+        error: errToShape(new exports.WorkflowStateError(options.name, stateIssues))
+      });
+    }
     return await runStepsLoop({
       options,
       steps,
@@ -1413,7 +1570,8 @@ async function executeWorkflow(options, steps, input, runOpts) {
       runId,
       startedAt,
       signal,
-      ...runOpts?.initialStepResults !== void 0 ? { initialStepResults: runOpts.initialStepResults } : {}
+      ...internal?.initialStepResults !== void 0 ? { initialStepResults: internal.initialStepResults } : {},
+      ...internal?.onStepEvent !== void 0 ? { onStepEvent: internal.onStepEvent } : {}
     });
   } finally {
     runSpan.end();
@@ -1444,28 +1602,17 @@ async function dispatchStep(step, input, ctx, options, prevStepResults) {
     }
   }
 }
-function assembleRun(params) {
-  const endedAt = Date.now();
-  return {
-    id: params.runId,
-    name: params.name,
-    status: params.status,
-    startedAt: params.startedAt,
-    endedAt,
-    stepResults: params.stepResults,
-    ...params.output !== void 0 ? { output: params.output } : {},
-    ...params.error !== void 0 ? { error: params.error } : {}
-  };
-}
 async function saveSnapshot(p) {
   const snapshot = {
-    _schemaVersion: 1,
+    _schemaVersion: 2,
+    // SE29 — carries `state`
     runId: p.runId,
     workflowName: p.workflowName,
     currentStepId: p.currentStepId,
     suspendedPayload: p.suspendedPayload,
     stepResults: p.stepResults,
     accumulatedInput: p.accumulatedInput,
+    ...p.state !== void 0 ? { state: p.state } : {},
     suspendedAt: Date.now()
   };
   const store = getSnapshotStoreFor(p.options);
@@ -1498,7 +1645,10 @@ async function resumeWorkflow(opts) {
     signal: opts.signal,
     runId: opts.runId,
     // M3 #62 — restore prior step outputs so the resumed run is not lossy (internal seam).
-    initialStepResults: snapshot.stepResults
+    initialStepResults: snapshot.stepResults,
+    // SE29 — restore shared state (v2 snapshot). A v1 snapshot has no `state` →
+    // executeWorkflow falls back to `options.initialState`.
+    ...snapshot.state !== void 0 ? { restoredState: snapshot.state } : {}
   });
 }
 var init_executor = __esm({
@@ -1506,6 +1656,7 @@ var init_executor = __esm({
     init_workflow();
     init_ctx();
     init_error_shape();
+    init_executor_helpers();
     init_run_id();
     init_single_flight();
     init_snapshot_store();
@@ -2244,6 +2395,43 @@ function sanitizeIdentifier(input, options) {
   }
   return input.toLowerCase();
 }
+
+// src/internal/workflow/event-stream.ts
+function createEventStream() {
+  const buffer = [];
+  const waiters = [];
+  let ended = false;
+  const stream = {
+    push(event) {
+      if (ended) return;
+      const waiter = waiters.shift();
+      if (waiter !== void 0) waiter({ value: event, done: false });
+      else buffer.push(event);
+    },
+    end() {
+      if (ended) return;
+      ended = true;
+      for (const waiter of waiters.splice(0)) waiter({ value: void 0, done: true });
+    },
+    next() {
+      const buffered = buffer.shift();
+      if (buffered !== void 0) return Promise.resolve({ value: buffered, done: false });
+      if (ended) return Promise.resolve({ value: void 0, done: true });
+      return new Promise((resolve2) => waiters.push(resolve2));
+    },
+    // `for await` calls return() on break/throw — close early so events stop
+    // buffering in memory for a consumer that stopped iterating.
+    return() {
+      stream.end();
+      buffer.length = 0;
+      return Promise.resolve({ value: void 0, done: true });
+    },
+    [Symbol.asyncIterator]() {
+      return stream;
+    }
+  };
+  return stream;
+}
 function toJsonSchema(schema, options = { unrepresentable: "any" }) {
   return zod.toJSONSchema(schema, options);
 }
@@ -2262,7 +2450,12 @@ var RetryPolicySchema = zod.z.object({
 });
 var WorkflowOptionsSchema = zod.z.object({
   name: zod.z.string().min(1).max(128),
-  persistence: PersistenceSchema
+  persistence: PersistenceSchema,
+  // SE27 — declared so a future `new WorkflowBuilder(parsed)` refactor cannot
+  // silently drop them (create() passes the ORIGINAL options today, but the
+  // schema is also the documentation of the shape).
+  inputSchema: zod.z.custom().optional(),
+  outputSchema: zod.z.custom().optional()
 });
 var WorkflowBuilder = class {
   /** @internal */
@@ -2439,6 +2632,36 @@ var Workflow = class {
     }
     return result;
   }
+  /**
+   * SE28 — run the workflow and STREAM step-level events as they happen. Returns
+   * an async iterator of {@link WorkflowEvent}s (`step_started` / `step_completed`
+   * / `step_failed` / `workflow_suspended` / `workflow_completed`, top-level
+   * steps) plus a `result` promise resolving to the same terminal
+   * {@link WorkflowRun} `run()` returns. Iterate for progress; await `result` for
+   * the outcome. The stream ends when the run terminates.
+   *
+   * `result` is the AUTHORITATIVE terminal status. Not every terminal state has a
+   * closing event: a step failure emits `step_failed`, but an `outputSchema`
+   * rejection (SE27) or an abort ends the stream WITHOUT `workflow_completed` —
+   * always `await result` to read the final `status`. Consuming order is free:
+   * awaiting `result` without draining, or draining without awaiting `result`,
+   * both work (breaking out of `for await` stops the buffering early).
+   */
+  stream(input, opts) {
+    const queue = createEventStream();
+    const result = (async () => {
+      const { executeWorkflow: executeWorkflow2 } = await Promise.resolve().then(() => (init_executor(), executor_exports));
+      try {
+        return await executeWorkflow2(this._options, this._steps, input, {
+          ...opts,
+          onStepEvent: (event) => queue.push(event)
+        });
+      } finally {
+        queue.end();
+      }
+    })();
+    return Object.assign(queue, { result });
+  }
   /**
    * Resume a suspended workflow from its snapshot. Throws
    * `WorkflowSnapshotNotFoundError` if `runId` is unknown.
@@ -2473,6 +2696,25 @@ function agentStep(id, agent, promptTemplate, opts) {
     ...opts?.origin !== void 0 ? { origin: opts.origin } : {}
   };
 }
+function workflowStep(child, opts) {
+  const id = opts?.id ?? `workflow_${child.__options.name}`;
+  validateStepId(id);
+  return {
+    kind: "fn",
+    id,
+    fn: async (input, ctx) => {
+      const run = await child.run(input, { signal: ctx.signal });
+      if (run.status === "completed") return run.output;
+      throw new exports.WorkflowNestedError(id, child.__options.name, run.status, run.error);
+    }
+  };
+}
+function cloneWorkflow(wf, opts) {
+  return new Workflow(
+    { ...wf.__options, name: opts.id, workflowId: `wf-${mintShortId()}` },
+    [...wf.__steps]
+  );
+}
 var WorkflowToolError = class extends Error {
   constructor(toolName, workflowStatus, workflowError) {
     super(
@@ -2535,7 +2777,9 @@ exports.WorkflowBuilder = WorkflowBuilder;
 exports.WorkflowToolError = WorkflowToolError;
 exports.__resetSnapshotStoresForTests = __resetSnapshotStoresForTests;
 exports.agentStep = agentStep;
+exports.cloneWorkflow = cloneWorkflow;
 exports.fn = fn;
 exports.workflowAsTool = workflowAsTool;
+exports.workflowStep = workflowStep;
 //# sourceMappingURL=workflow.cjs.map
 //# sourceMappingURL=workflow.cjs.map