pipeai 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,13 +1,16 @@
-import { Tool, FlexibleSchema, ToolExecutionOptions, streamText, generateText, Output, LanguageModel, ModelMessage, ToolChoice, ToolSet, StopCondition, OnStepFinishEvent, OnFinishEvent, GenerateTextResult as GenerateTextResult$1, StreamTextResult as StreamTextResult$1, UIMessageStreamWriter } from 'ai';
+import { Tool, ToolExecutionOptions, UIMessageStreamWriter, FlexibleSchema, streamText, generateText, Output, LanguageModel, ModelMessage, ToolChoice, ToolSet, StopCondition, OnStepFinishEvent, OnFinishEvent, GenerateTextResult as GenerateTextResult$1, StreamTextResult as StreamTextResult$1 } from 'ai';
 import { ZodType } from 'zod';
 
 declare const TOOL_PROVIDER_BRAND: unique symbol;
+type ToolExecuteOptions = ToolExecutionOptions & {
+    writer?: UIMessageStreamWriter;
+};
 type ToolProviderConfig<TContext, TInput, TOutput> = {
     description?: string;
     input: FlexibleSchema<TInput>;
     output?: FlexibleSchema<unknown>;
     providerOptions?: unknown;
-    execute: (input: TInput, ctx: Readonly<TContext>, options?: ToolExecutionOptions) => Promise<TOutput>;
+    execute: (input: TInput, ctx: Readonly<TContext>, options: ToolExecuteOptions) => Promise<TOutput>;
 };
 interface IToolProvider<TContext> {
     readonly [TOOL_PROVIDER_BRAND]: true;
@@ -56,16 +59,19 @@ interface AgentConfig<TContext, TInput = void, TOutput = void> extends AIPassthr
         result: OnStepFinishEvent;
         ctx: Readonly<TContext>;
         input: TInput;
+        writer?: UIMessageStreamWriter;
     }) => MaybePromise<void>;
     onFinish?: (params: {
         result: OnFinishEvent;
         ctx: Readonly<TContext>;
         input: TInput;
+        writer?: UIMessageStreamWriter;
     }) => MaybePromise<void>;
     onError?: (params: {
         error: unknown;
         ctx: Readonly<TContext>;
         input: TInput;
+        writer?: UIMessageStreamWriter;
     }) => MaybePromise<void>;
 }
 declare class Agent<TContext, TInput = void, TOutput = void> {
@@ -103,6 +109,17 @@ declare class WorkflowLoopError extends Error {
     readonly maxIterations: number;
     constructor(iterations: number, maxIterations: number);
 }
+interface WorkflowSnapshot {
+    readonly version: 1;
+    readonly resumeFromIndex: number;
+    readonly output: unknown;
+    readonly gateId: string;
+    readonly gatePayload: unknown;
+}
+declare class WorkflowSuspended extends Error {
+    readonly snapshot: WorkflowSnapshot;
+    constructor(snapshot: WorkflowSnapshot);
+}
 interface AgentStepHooks<TContext, TOutput, TNextOutput> {
     mapGenerateResult?: (params: {
         result: GenerateTextResult;
@@ -172,6 +189,9 @@ type RepeatOptions<TContext, TOutput> = {
     maxIterations?: number;
 };
 type ElementOf<T> = T extends readonly (infer E)[] ? E : never;
+interface SchemaWithParse<T = unknown> {
+    parse(data: unknown): T;
+}
 type StepNode = {
     readonly type: "step";
     readonly id: string;
@@ -189,6 +209,16 @@ type StepNode = {
     readonly type: "finally";
     readonly id: string;
     readonly execute: (state: RuntimeState) => MaybePromise<void>;
+} | {
+    readonly type: "gate";
+    readonly id: string;
+    readonly payload: (state: RuntimeState) => MaybePromise<unknown>;
+    readonly schema?: SchemaWithParse;
+    readonly condition?: (state: RuntimeState) => MaybePromise<boolean>;
+    readonly merge?: (params: {
+        priorOutput: unknown;
+        response: unknown;
+    }) => MaybePromise<unknown>;
 };
 interface RuntimeState {
     ctx: unknown;
@@ -196,45 +226,76 @@ interface RuntimeState {
     mode: "generate" | "stream";
     writer?: UIMessageStreamWriter;
 }
-declare class SealedWorkflow<TContext, TInput = void, TOutput = void> {
+declare class SealedWorkflow<TContext, TInput = void, TOutput = void, TGates extends Record<string, unknown> = {}> {
     readonly id?: string;
     protected readonly steps: ReadonlyArray<StepNode>;
     protected constructor(steps: ReadonlyArray<StepNode>, id?: string);
     generate(ctx: TContext, ...args: TInput extends void ? [input?: TInput] : [input: TInput]): Promise<WorkflowResult<TOutput>>;
     stream(ctx: TContext, ...args: TInput extends void ? [input?: TInput, options?: WorkflowStreamOptions] : [input: TInput, options?: WorkflowStreamOptions]): WorkflowStreamResult<TOutput>;
-    protected execute(state: RuntimeState): Promise<void>;
-    protected executeNestedWorkflow(state: RuntimeState, workflow: SealedWorkflow<TContext, unknown, unknown>): Promise<void>;
+    protected execute(state: RuntimeState, startIndex?: number): Promise<void>;
+    protected executeNestedWorkflow(state: RuntimeState, workflow: SealedWorkflow<TContext, unknown, unknown, any>): Promise<void>;
     protected executeAgent<TAgentInput, TNextOutput>(state: RuntimeState, agent: Agent<TContext, any, TNextOutput>, ctx: TContext, options?: AgentStepHooks<TContext, any, TNextOutput>): Promise<void>;
+    loadState<K extends string & keyof TGates>(gateId: K, snapshot: WorkflowSnapshot): ResumedWorkflow<TContext, TGates[K], TOutput>;
+    private findGateIndex;
+}
+declare class ResumedWorkflow<TContext, TResponse = unknown, TOutput = void> extends SealedWorkflow<TContext, TResponse, TOutput> {
+    private readonly startIndex;
+    private readonly schema?;
+    private readonly mergeFn?;
+    private readonly priorOutput;
+    /** @internal */
+    constructor(steps: ReadonlyArray<StepNode>, startIndex: number, schema?: SchemaWithParse<TResponse>, mergeFn?: (params: {
+        priorOutput: unknown;
+        response: unknown;
+    }) => MaybePromise<unknown>, priorOutput?: unknown);
+    private validateResponse;
+    generate(ctx: TContext, ...args: TResponse extends void ? [response?: TResponse] : [response: TResponse]): Promise<WorkflowResult<TOutput>>;
+    stream(ctx: TContext, ...args: TResponse extends void ? [response?: TResponse, options?: WorkflowStreamOptions] : [response: TResponse, options?: WorkflowStreamOptions]): WorkflowStreamResult<TOutput>;
 }
-declare class Workflow<TContext, TInput = void, TOutput = void> extends SealedWorkflow<TContext, TInput, TOutput> {
+declare class Workflow<TContext, TInput = void, TOutput = void, TGates extends Record<string, unknown> = {}> extends SealedWorkflow<TContext, TInput, TOutput, TGates> {
     private constructor();
     static create<TContext, TInput = void>(options?: {
         id?: string;
     }): Workflow<TContext, TInput, TInput>;
     static from<TContext, TInput, TOutput>(agent: Agent<TContext, TInput, TOutput>, options?: StepOptions<TContext, TInput, TOutput>): Workflow<TContext, TInput, TOutput>;
-    step<TNextOutput>(agent: Agent<TContext, TOutput, TNextOutput>, options?: StepOptions<TContext, TOutput, TNextOutput>): Workflow<TContext, TInput, TNextOutput>;
-    step<TNextOutput>(workflow: SealedWorkflow<TContext, TOutput, TNextOutput>): Workflow<TContext, TInput, TNextOutput>;
+    step<TNextOutput>(agent: Agent<TContext, TOutput, TNextOutput>, options?: StepOptions<TContext, TOutput, TNextOutput>): Workflow<TContext, TInput, TNextOutput, TGates>;
+    step<TNextOutput>(workflow: SealedWorkflow<TContext, TOutput, TNextOutput>): Workflow<TContext, TInput, TNextOutput, TGates>;
     step<TNextOutput>(id: string, fn: (params: {
         ctx: Readonly<TContext>;
         input: TOutput;
-    }) => MaybePromise<TNextOutput>): Workflow<TContext, TInput, TNextOutput>;
-    branch<TNextOutput>(cases: BranchCase<TContext, TOutput, TNextOutput>[]): Workflow<TContext, TInput, TNextOutput>;
-    branch<TKeys extends string, TNextOutput>(config: BranchSelect<TContext, TOutput, TKeys, TNextOutput>): Workflow<TContext, TInput, TNextOutput>;
+    }) => MaybePromise<TNextOutput>): Workflow<TContext, TInput, TNextOutput, TGates>;
+    gate<TResponse = TOutput, Id extends string = string>(id: Id & (Id extends keyof TGates ? never : Id), options?: {
+        payload?: (params: {
+            ctx: Readonly<TContext>;
+            input: TOutput;
+        }) => MaybePromise<unknown>;
+        schema?: SchemaWithParse<TResponse>;
+        condition?: (params: {
+            ctx: Readonly<TContext>;
+            input: TOutput;
+        }) => MaybePromise<boolean>;
+        merge?: (params: {
+            priorOutput: TOutput;
+            response: TResponse;
+        }) => MaybePromise<TResponse>;
+    }): Workflow<TContext, TInput, TResponse, TGates & Record<Id, TResponse>>;
+    branch<TNextOutput>(cases: BranchCase<TContext, TOutput, TNextOutput>[]): Workflow<TContext, TInput, TNextOutput, TGates>;
+    branch<TKeys extends string, TNextOutput>(config: BranchSelect<TContext, TOutput, TKeys, TNextOutput>): Workflow<TContext, TInput, TNextOutput, TGates>;
     private branchPredicate;
     private branchSelect;
     foreach<TNextOutput>(target: Agent<TContext, ElementOf<TOutput>, TNextOutput> | SealedWorkflow<TContext, ElementOf<TOutput>, TNextOutput>, options?: {
         concurrency?: number;
-    }): Workflow<TContext, TInput, TNextOutput[]>;
-    repeat(target: Agent<TContext, TOutput, TOutput> | SealedWorkflow<TContext, TOutput, TOutput>, options: RepeatOptions<TContext, TOutput>): Workflow<TContext, TInput, TOutput>;
+    }): Workflow<TContext, TInput, TNextOutput[], TGates>;
+    repeat(target: Agent<TContext, TOutput, TOutput> | SealedWorkflow<TContext, TOutput, TOutput>, options: RepeatOptions<TContext, TOutput>): Workflow<TContext, TInput, TOutput, TGates>;
     catch(id: string, fn: (params: {
         error: unknown;
         ctx: Readonly<TContext>;
         lastOutput: TOutput;
         stepId: string;
-    }) => MaybePromise<TOutput>): Workflow<TContext, TInput, TOutput>;
+    }) => MaybePromise<TOutput>): Workflow<TContext, TInput, TOutput, TGates>;
     finally(id: string, fn: (params: {
         ctx: Readonly<TContext>;
-    }) => MaybePromise<void>): SealedWorkflow<TContext, TInput, TOutput>;
+    }) => MaybePromise<void>): SealedWorkflow<TContext, TInput, TOutput, TGates>;
 }
 
-export { Agent, type AgentConfig, type AgentStepHooks, type BranchCase, type BranchSelect, type GenerateTextResult, type IToolProvider, type MaybePromise, type RepeatOptions, type Resolvable, SealedWorkflow, type StepOptions, type StreamTextResult, type ToolProviderConfig, Workflow, WorkflowBranchError, WorkflowLoopError, type WorkflowResult, type WorkflowStreamOptions, type WorkflowStreamResult, defineTool };
+export { Agent, type AgentConfig, type AgentStepHooks, type BranchCase, type BranchSelect, type GenerateTextResult, type IToolProvider, type MaybePromise, type RepeatOptions, type Resolvable, ResumedWorkflow, SealedWorkflow, type StepOptions, type StreamTextResult, type ToolExecuteOptions, type ToolProviderConfig, Workflow, WorkflowBranchError, WorkflowLoopError, type WorkflowResult, type WorkflowSnapshot, type WorkflowStreamOptions, type WorkflowStreamResult, WorkflowSuspended, defineTool };

package/dist/index.js

@@ -7,6 +7,31 @@ import {
 
 // src/tool-provider.ts
 import { tool } from "ai";
+
+// src/utils.ts
+import { AsyncLocalStorage } from "async_hooks";
+var writerStorage = new AsyncLocalStorage();
+function runWithWriter(writer, fn) {
+  return writerStorage.run(writer, fn);
+}
+function getActiveWriter() {
+  return writerStorage.getStore();
+}
+function resolveValue(value, ctx, input) {
+  if (typeof value === "function") {
+    return value(ctx, input);
+  }
+  return value;
+}
+async function extractOutput(result, hasStructuredOutput) {
+  if (hasStructuredOutput) {
+    const output = await result.output;
+    if (output !== void 0) return output;
+  }
+  return await result.text;
+}
+
+// src/tool-provider.ts
 var TOOL_PROVIDER_BRAND = /* @__PURE__ */ Symbol.for("agent-workflow.ToolProvider");
 var ToolProvider = class {
   [TOOL_PROVIDER_BRAND] = true;
@@ -19,7 +44,7 @@ var ToolProvider = class {
     return tool({
       ...toolDef,
       parameters: inputSchema,
-      execute: (input, options) => execute(input, context, options)
+      execute: (input, options) => execute(input, context, { ...options, writer: getActiveWriter() })
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
     });
   }
@@ -31,21 +56,6 @@ function isToolProvider(obj) {
   return typeof obj === "object" && obj !== null && TOOL_PROVIDER_BRAND in obj;
 }
 
-// src/utils.ts
-function resolveValue(value, ctx, input) {
-  if (typeof value === "function") {
-    return value(ctx, input);
-  }
-  return value;
-}
-async function extractOutput(result, hasStructuredOutput) {
-  if (hasStructuredOutput) {
-    const output = await result.output;
-    if (output !== void 0) return output;
-  }
-  return await result.text;
-}
-
 // src/agent.ts
 var Agent = class {
   id;
@@ -110,7 +120,7 @@ var Agent = class {
       return await generateText(options);
     } catch (error) {
       if (this.config.onError) {
-        await this.config.onError({ error, ctx, input });
+        await this.config.onError({ error, ctx, input, writer: getActiveWriter() });
       }
       throw error;
     }
@@ -121,7 +131,7 @@ var Agent = class {
     const options = this.buildCallOptions(resolved, ctx, input);
     return streamText({
       ...options,
-      onError: this.config.onError ? ({ error }) => this.config.onError({ error, ctx, input }) : void 0
+      onError: this.config.onError ? ({ error }) => this.config.onError({ error, ctx, input, writer: getActiveWriter() }) : void 0
     });
   }
   asTool(ctx, options) {
@@ -144,6 +154,13 @@ var Agent = class {
       description: this.description,
       parameters: this.config.input,
       execute: async (toolInput) => {
+        const writer = getActiveWriter();
+        if (writer) {
+          const result2 = await this.stream(ctx, toolInput);
+          writer.merge(result2.toUIMessageStream());
+          if (options?.mapOutput) return options.mapOutput(result2);
+          return extractOutput(result2, this.hasOutput);
+        }
         const result = await this.generate(ctx, toolInput);
         if (options?.mapOutput) return options.mapOutput(result);
         return extractOutput(result, this.hasOutput);
@@ -163,8 +180,8 @@ var Agent = class {
       ...resolved.messages ? { messages: resolved.messages } : { prompt: resolved.prompt ?? "" },
       ...resolved.system ? { system: resolved.system } : {},
       ...this.config.output ? { output: this.config.output } : {},
-      onStepFinish: this._onStepFinish ? (event) => this._onStepFinish({ result: event, ctx, input }) : void 0,
-      onFinish: this._onFinish ? (event) => this._onFinish({ result: event, ctx, input }) : void 0
+      onStepFinish: this._onStepFinish ? (event) => this._onStepFinish({ result: event, ctx, input, writer: getActiveWriter() }) : void 0,
+      onFinish: this._onFinish ? (event) => this._onFinish({ result: event, ctx, input, writer: getActiveWriter() }) : void 0
     };
   }
   resolveConfig(ctx, input) {
@@ -235,6 +252,14 @@ var WorkflowLoopError = class extends Error {
     this.name = "WorkflowLoopError";
   }
 };
+var WorkflowSuspended = class extends Error {
+  snapshot;
+  constructor(snapshot) {
+    super(`Workflow suspended at gate "${snapshot.gateId}"`);
+    this.name = "WorkflowSuspended";
+    this.snapshot = snapshot;
+  }
+};
 var SealedWorkflow = class {
   id;
   steps;
@@ -291,12 +316,13 @@ var SealedWorkflow = class {
     };
   }
   // ── Internal: execute pipeline ────────────────────────────────
-  async execute(state) {
+  async execute(state, startIndex = 0) {
     if (this.steps.length === 0) {
       throw new Error("Workflow has no steps. Add at least one step before calling generate() or stream().");
     }
     let pendingError = null;
-    for (const node of this.steps) {
+    for (let i = startIndex; i < this.steps.length; i++) {
+      const node = this.steps[i];
       if (node.type === "finally") {
         await node.execute(state);
         continue;
@@ -316,10 +342,26 @@ var SealedWorkflow = class {
         }
         continue;
       }
+      if (node.type === "gate") {
+        if (pendingError) continue;
+        if (node.condition) {
+          const shouldSuspend = await node.condition(state);
+          if (!shouldSuspend) continue;
+        }
+        const gatePayload = await node.payload(state);
+        throw new WorkflowSuspended({
+          version: 1,
+          resumeFromIndex: i,
+          output: state.output,
+          gateId: node.id,
+          gatePayload
+        });
+      }
       if (pendingError) continue;
       try {
         await node.execute(state);
       } catch (error) {
+        if (error instanceof WorkflowSuspended) throw error;
         pendingError = { error, stepId: node.id };
       }
     }
@@ -329,7 +371,16 @@ var SealedWorkflow = class {
   // Defined on SealedWorkflow (not Workflow) because TypeScript's protected
   // access rules only allow calling workflow.execute() from the same class.
   async executeNestedWorkflow(state, workflow) {
-    await workflow.execute(state);
+    try {
+      await workflow.execute(state);
+    } catch (error) {
+      if (error instanceof WorkflowSuspended) {
+        throw new Error(
+          `Gates inside nested workflows are not yet supported. Gate "${error.snapshot.gateId}" was hit inside nested workflow "${workflow.id ?? "(anonymous)"}". Consider using a conditional gate with \`condition\` to skip when criteria are met, or restructure the workflow to use gates at the top level only.`
+        );
+      }
+      throw error;
+    }
   }
   // ── Internal: execute an agent within a step/branch ───────────
   // In stream mode, output extraction awaits the full stream before returning.
@@ -339,20 +390,23 @@ var SealedWorkflow = class {
     const input = state.output;
     const hasStructuredOutput = agent.hasOutput;
     if (state.mode === "stream" && state.writer) {
-      const result = await agent.stream(ctx, state.output);
-      if (options?.handleStream) {
-        await options.handleStream({ result, writer: state.writer, ctx });
-      } else {
-        state.writer.merge(result.toUIMessageStream());
-      }
-      if (options?.onStreamResult) {
-        await options.onStreamResult({ result, ctx, input });
-      }
-      if (options?.mapStreamResult) {
-        state.output = await options.mapStreamResult({ result, ctx, input });
-      } else {
-        state.output = await extractOutput(result, hasStructuredOutput);
-      }
+      const writer = state.writer;
+      await runWithWriter(writer, async () => {
+        const result = await agent.stream(ctx, state.output);
+        if (options?.handleStream) {
+          await options.handleStream({ result, writer, ctx });
+        } else {
+          writer.merge(result.toUIMessageStream());
+        }
+        if (options?.onStreamResult) {
+          await options.onStreamResult({ result, ctx, input });
+        }
+        if (options?.mapStreamResult) {
+          state.output = await options.mapStreamResult({ result, ctx, input });
+        } else {
+          state.output = await extractOutput(result, hasStructuredOutput);
+        }
+      });
     } else {
       const result = await agent.generate(ctx, state.output);
       if (options?.onGenerateResult) {
@@ -365,6 +419,106 @@ var SealedWorkflow = class {
       }
     }
   }
+  // ── Gate: load persisted state for resumption ──────────────────
+  loadState(gateId, snapshot) {
+    if (snapshot.gateId !== gateId) {
+      throw new Error(
+        `loadState: gate ID mismatch \u2014 expected "${gateId}" but snapshot has "${snapshot.gateId}".`
+      );
+    }
+    const gateIndex = this.findGateIndex(snapshot);
+    const gateNode = this.steps[gateIndex];
+    return new ResumedWorkflow(
+      this.steps,
+      gateIndex + 1,
+      gateNode.schema,
+      gateNode.merge,
+      snapshot.output
+    );
+  }
+  findGateIndex(snapshot) {
+    if (snapshot.version !== 1) {
+      throw new Error(`Unsupported snapshot version: ${snapshot.version}`);
+    }
+    const hint = snapshot.resumeFromIndex;
+    if (hint >= 0 && hint < this.steps.length) {
+      const node = this.steps[hint];
+      if (node.type === "gate" && node.id === snapshot.gateId) {
+        return hint;
+      }
+    }
+    for (let i = 0; i < this.steps.length; i++) {
+      const node = this.steps[i];
+      if (node.type === "gate" && node.id === snapshot.gateId) {
+        return i;
+      }
+    }
+    throw new Error(
+      `Gate "${snapshot.gateId}" not found in workflow. The workflow definition may have changed since the snapshot was created.`
+    );
+  }
+};
+var ResumedWorkflow = class extends SealedWorkflow {
+  startIndex;
+  schema;
+  mergeFn;
+  priorOutput;
+  /** @internal */
+  constructor(steps, startIndex, schema, mergeFn, priorOutput) {
+    super(steps);
+    this.startIndex = startIndex;
+    this.schema = schema;
+    this.mergeFn = mergeFn;
+    this.priorOutput = priorOutput;
+  }
+  validateResponse(response) {
+    if (this.schema) {
+      return this.schema.parse(response);
+    }
+    return response;
+  }
+  async generate(ctx, ...args) {
+    const response = this.validateResponse(args[0]);
+    const output = this.mergeFn ? await this.mergeFn({ priorOutput: this.priorOutput, response }) : response;
+    const state = { ctx, output, mode: "generate" };
+    await this.execute(state, this.startIndex);
+    return { output: state.output };
+  }
+  stream(ctx, ...args) {
+    const response = this.validateResponse(args[0]);
+    const options = args[1];
+    let resolveOutput;
+    let rejectOutput;
+    const outputPromise = new Promise((res, rej) => {
+      resolveOutput = res;
+      rejectOutput = rej;
+    });
+    outputPromise.catch(() => {
+    });
+    const mergeFn = this.mergeFn;
+    const priorOutput = this.priorOutput;
+    const stream = createUIMessageStream({
+      execute: async ({ writer }) => {
+        const output = mergeFn ? await mergeFn({ priorOutput, response }) : response;
+        const state = {
+          ctx,
+          output,
+          mode: "stream",
+          writer
+        };
+        try {
+          await this.execute(state, this.startIndex);
+          resolveOutput(state.output);
+        } catch (error) {
+          rejectOutput(error);
+          throw error;
+        }
+      },
+      ...options?.onError ? { onError: options.onError } : {},
+      ...options?.onFinish ? { onFinish: options.onFinish } : {}
+    });
+    return { stream, output: outputPromise };
+  }
 };
 var Workflow = class _Workflow extends SealedWorkflow {
   constructor(steps = [], id) {
@@ -418,6 +572,32 @@ var Workflow = class _Workflow extends SealedWorkflow {
     };
     return new _Workflow([...this.steps, node], this.id);
   }
+  // ── gate: human-in-the-loop suspension point ────────────────
+  gate(id, options) {
+    if (this.steps.some((s) => s.type === "gate" && s.id === id)) {
+      throw new Error(`Workflow: duplicate gate ID "${id}". Each gate must have a unique identifier.`);
+    }
+    const node = {
+      type: "gate",
+      id,
+      schema: options?.schema,
+      condition: options?.condition ? async (state) => options.condition({
+        ctx: state.ctx,
+        input: state.output
+      }) : void 0,
+      merge: options?.merge ? (params) => options.merge(params) : void 0,
+      payload: async (state) => {
+        if (options?.payload) {
+          return options.payload({
+            ctx: state.ctx,
+            input: state.output
+          });
+        }
+        return state.output;
+      }
+    };
+    return new _Workflow([...this.steps, node], this.id);
+  }
   // ── branch: implementation ────────────────────────────────────
   branch(casesOrConfig) {
     if (Array.isArray(casesOrConfig)) {
@@ -563,6 +743,7 @@ export {
   Workflow,
   WorkflowBranchError,
   WorkflowLoopError,
+  WorkflowSuspended,
   defineTool
 };
 //# sourceMappingURL=index.js.map