pipeai 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -24,6 +24,7 @@ __export(index_exports, {
   Workflow: () => Workflow,
   WorkflowBranchError: () => WorkflowBranchError,
   WorkflowLoopError: () => WorkflowLoopError,
+  WorkflowSuspended: () => WorkflowSuspended,
   defineTool: () => defineTool
 });
 module.exports = __toCommonJS(index_exports);
@@ -33,6 +34,31 @@ var import_ai2 = require("ai");
 
 // src/tool-provider.ts
 var import_ai = require("ai");
+
+// src/utils.ts
+var import_node_async_hooks = require("async_hooks");
+var writerStorage = new import_node_async_hooks.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;
@@ -45,7 +71,7 @@ var ToolProvider = class {
     return (0, import_ai.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
     });
   }
@@ -57,21 +83,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;
@@ -136,7 +147,7 @@ var Agent = class {
       return await (0, import_ai2.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;
     }
@@ -147,7 +158,7 @@ var Agent = class {
     const options = this.buildCallOptions(resolved, ctx, input);
     return (0, import_ai2.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) {
@@ -170,6 +181,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);
@@ -189,8 +207,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) {
@@ -259,6 +277,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;
@@ -315,12 +341,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;
@@ -340,10 +367,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 };
       }
     }
@@ -353,7 +396,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.
@@ -363,20 +415,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) {
@@ -389,6 +444,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 = (0, import_ai3.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) {
@@ -442,6 +597,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)) {
@@ -588,6 +769,7 @@ var Workflow = class _Workflow extends SealedWorkflow {
   Workflow,
   WorkflowBranchError,
   WorkflowLoopError,
+  WorkflowSuspended,
   defineTool
 });
 //# sourceMappingURL=index.cjs.map