pipeai 0.1.0

package/dist/index.cjs

@@ -0,0 +1,593 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Agent: () => Agent,
+  Workflow: () => Workflow,
+  WorkflowBranchError: () => WorkflowBranchError,
+  WorkflowLoopError: () => WorkflowLoopError,
+  defineTool: () => defineTool
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/agent.ts
+var import_ai2 = require("ai");
+
+// src/tool-provider.ts
+var import_ai = require("ai");
+var TOOL_PROVIDER_BRAND = /* @__PURE__ */ Symbol.for("agent-workflow.ToolProvider");
+var ToolProvider = class {
+  [TOOL_PROVIDER_BRAND] = true;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  createTool(context) {
+    const { execute, input: inputSchema, ...toolDef } = this.config;
+    return (0, import_ai.tool)({
+      ...toolDef,
+      parameters: inputSchema,
+      execute: (input, options) => execute(input, context, options)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+  }
+};
+function defineTool() {
+  return (config) => new ToolProvider(config);
+}
+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;
+  description;
+  hasOutput;
+  config;
+  _hasDynamicConfig;
+  _resolvedStaticTools = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  _passthrough;
+  _onStepFinish;
+  _onFinish;
+  constructor(config) {
+    this.id = config.id;
+    this.description = config.description ?? "";
+    this.hasOutput = config.output !== void 0;
+    this.config = config;
+    this._hasDynamicConfig = [
+      config.model,
+      config.system,
+      config.prompt,
+      config.messages,
+      config.tools,
+      config.activeTools,
+      config.toolChoice,
+      config.stopWhen
+    ].some((v) => typeof v === "function");
+    if (!this._hasDynamicConfig) {
+      const rawTools = config.tools ?? {};
+      const hasProvider = Object.values(rawTools).some((v) => isToolProvider(v));
+      if (!hasProvider) {
+        this._resolvedStaticTools = rawTools;
+      }
+    }
+    const {
+      id: _id,
+      description: _desc,
+      input: _inputSchema,
+      output: _output,
+      model: _m,
+      system: _s,
+      prompt: _p,
+      messages: _msg,
+      tools: _t,
+      activeTools: _at,
+      toolChoice: _tc,
+      stopWhen: _sw,
+      onStepFinish,
+      onFinish,
+      onError: _onError,
+      ...passthrough
+    } = config;
+    this._passthrough = passthrough;
+    this._onStepFinish = onStepFinish;
+    this._onFinish = onFinish;
+  }
+  async generate(ctx, ...args) {
+    const input = args[0];
+    const resolved = await this.resolveConfig(ctx, input);
+    const options = this.buildCallOptions(resolved, ctx, input);
+    try {
+      return await (0, import_ai2.generateText)(options);
+    } catch (error) {
+      if (this.config.onError) {
+        await this.config.onError({ error, ctx, input });
+      }
+      throw error;
+    }
+  }
+  async stream(ctx, ...args) {
+    const input = args[0];
+    const resolved = await this.resolveConfig(ctx, input);
+    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
+    });
+  }
+  asTool(ctx, options) {
+    return this.createToolInstance(ctx, options);
+  }
+  asToolProvider(options) {
+    if (!this.config.input) {
+      throw new Error(`Agent "${this.id}": asToolProvider() requires an input schema`);
+    }
+    return {
+      [TOOL_PROVIDER_BRAND]: true,
+      createTool: (ctx) => this.createToolInstance(ctx, options)
+    };
+  }
+  createToolInstance(ctx, options) {
+    if (!this.config.input) {
+      throw new Error(`Agent "${this.id}": asTool() requires an input schema`);
+    }
+    return (0, import_ai2.tool)({
+      description: this.description,
+      parameters: this.config.input,
+      execute: async (toolInput) => {
+        const result = await this.generate(ctx, toolInput);
+        if (options?.mapOutput) return options.mapOutput(result);
+        return extractOutput(result, this.hasOutput);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  buildCallOptions(resolved, ctx, input) {
+    return {
+      ...this._passthrough,
+      model: resolved.model,
+      tools: resolved.tools,
+      activeTools: resolved.activeTools,
+      toolChoice: resolved.toolChoice,
+      stopWhen: resolved.stopWhen,
+      ...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
+    };
+  }
+  resolveConfig(ctx, input) {
+    if (!this._hasDynamicConfig) {
+      return {
+        model: this.config.model,
+        prompt: this.config.prompt,
+        system: this.config.system,
+        messages: this.config.messages,
+        tools: this._resolvedStaticTools ?? this.resolveTools(
+          this.config.tools ?? {},
+          ctx
+        ),
+        activeTools: this.config.activeTools,
+        toolChoice: this.config.toolChoice,
+        stopWhen: this.config.stopWhen
+      };
+    }
+    return this.resolveConfigAsync(ctx, input);
+  }
+  async resolveConfigAsync(ctx, input) {
+    const [model, prompt, system, messages, rawTools, activeTools, toolChoice, stopWhen] = await Promise.all([
+      resolveValue(this.config.model, ctx, input),
+      resolveValue(this.config.prompt, ctx, input),
+      resolveValue(this.config.system, ctx, input),
+      resolveValue(this.config.messages, ctx, input),
+      resolveValue(this.config.tools, ctx, input),
+      resolveValue(this.config.activeTools, ctx, input),
+      resolveValue(this.config.toolChoice, ctx, input),
+      resolveValue(this.config.stopWhen, ctx, input)
+    ]);
+    const tools = this.resolveTools(rawTools ?? {}, ctx);
+    return { model, prompt, system, messages, tools, activeTools, toolChoice, stopWhen };
+  }
+  resolveTools(tools, ctx) {
+    const entries = Object.entries(tools);
+    if (entries.length === 0) return tools;
+    let hasProvider = false;
+    const resolved = {};
+    for (const [key, toolOrProvider] of entries) {
+      if (isToolProvider(toolOrProvider)) {
+        hasProvider = true;
+        resolved[key] = toolOrProvider.createTool(ctx);
+      } else {
+        resolved[key] = toolOrProvider;
+      }
+    }
+    return hasProvider ? resolved : tools;
+  }
+};
+
+// src/workflow.ts
+var import_ai3 = require("ai");
+var WorkflowBranchError = class extends Error {
+  constructor(branchType, message) {
+    super(message);
+    this.branchType = branchType;
+    this.name = "WorkflowBranchError";
+  }
+};
+var WorkflowLoopError = class extends Error {
+  constructor(iterations, maxIterations) {
+    super(`Loop exceeded maximum iterations (${maxIterations})`);
+    this.iterations = iterations;
+    this.maxIterations = maxIterations;
+    this.name = "WorkflowLoopError";
+  }
+};
+var SealedWorkflow = class {
+  id;
+  steps;
+  constructor(steps, id) {
+    this.steps = steps;
+    this.id = id;
+  }
+  // ── Execution ─────────────────────────────────────────────────
+  async generate(ctx, ...args) {
+    const input = args[0];
+    const state = {
+      ctx,
+      output: input,
+      mode: "generate"
+    };
+    await this.execute(state);
+    return {
+      output: state.output
+    };
+  }
+  stream(ctx, ...args) {
+    const input = args[0];
+    const options = args[1];
+    let resolveOutput;
+    let rejectOutput;
+    const outputPromise = new Promise((res, rej) => {
+      resolveOutput = res;
+      rejectOutput = rej;
+    });
+    outputPromise.catch(() => {
+    });
+    const stream = (0, import_ai3.createUIMessageStream)({
+      execute: async ({ writer }) => {
+        const state = {
+          ctx,
+          output: input,
+          mode: "stream",
+          writer
+        };
+        try {
+          await this.execute(state);
+          resolveOutput(state.output);
+        } catch (error) {
+          rejectOutput(error);
+          throw error;
+        }
+      },
+      ...options?.onError ? { onError: options.onError } : {},
+      ...options?.onFinish ? { onFinish: options.onFinish } : {}
+    });
+    return {
+      stream,
+      output: outputPromise
+    };
+  }
+  // ── Internal: execute pipeline ────────────────────────────────
+  async execute(state) {
+    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) {
+      if (node.type === "finally") {
+        await node.execute(state);
+        continue;
+      }
+      if (node.type === "catch") {
+        if (!pendingError) continue;
+        try {
+          state.output = await node.catchFn({
+            error: pendingError.error,
+            ctx: state.ctx,
+            lastOutput: state.output,
+            stepId: pendingError.stepId
+          });
+          pendingError = null;
+        } catch (catchError) {
+          pendingError = { error: catchError, stepId: node.id };
+        }
+        continue;
+      }
+      if (pendingError) continue;
+      try {
+        await node.execute(state);
+      } catch (error) {
+        pendingError = { error, stepId: node.id };
+      }
+    }
+    if (pendingError) throw pendingError.error;
+  }
+  // ── Internal: execute a nested workflow within a step/loop ─────
+  // 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);
+  }
+  // ── Internal: execute an agent within a step/branch ───────────
+  // In stream mode, output extraction awaits the full stream before returning.
+  // Streaming benefits the client (incremental output), not pipeline throughput —
+  // each step still runs sequentially.
+  async executeAgent(state, agent, ctx, options) {
+    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);
+      }
+    } else {
+      const result = await agent.generate(ctx, state.output);
+      if (options?.onGenerateResult) {
+        await options.onGenerateResult({ result, ctx, input });
+      }
+      if (options?.mapGenerateResult) {
+        state.output = await options.mapGenerateResult({ result, ctx, input });
+      } else {
+        state.output = await extractOutput(result, hasStructuredOutput);
+      }
+    }
+  }
+};
+var Workflow = class _Workflow extends SealedWorkflow {
+  constructor(steps = [], id) {
+    super(steps, id);
+  }
+  static create(options) {
+    return new _Workflow([], options?.id);
+  }
+  static from(agent, options) {
+    return new _Workflow([]).step(agent, options);
+  }
+  // ── step: implementation ──────────────────────────────────────
+  step(target, optionsOrFn) {
+    if (target instanceof SealedWorkflow) {
+      const workflow = target;
+      const node2 = {
+        type: "step",
+        id: workflow.id ?? "nested-workflow",
+        execute: async (state) => {
+          await this.executeNestedWorkflow(state, workflow);
+        }
+      };
+      return new _Workflow([...this.steps, node2], this.id);
+    }
+    if (typeof target === "string") {
+      if (typeof optionsOrFn !== "function") {
+        throw new Error(`Workflow step("${target}"): second argument must be a function`);
+      }
+      const fn = optionsOrFn;
+      const node2 = {
+        type: "step",
+        id: target,
+        execute: async (state) => {
+          state.output = await fn({
+            ctx: state.ctx,
+            input: state.output
+          });
+        }
+      };
+      return new _Workflow([...this.steps, node2], this.id);
+    }
+    const agent = target;
+    const options = optionsOrFn;
+    const node = {
+      type: "step",
+      id: agent.id,
+      execute: async (state) => {
+        const ctx = state.ctx;
+        await this.executeAgent(state, agent, ctx, options);
+      }
+    };
+    return new _Workflow([...this.steps, node], this.id);
+  }
+  // ── branch: implementation ────────────────────────────────────
+  branch(casesOrConfig) {
+    if (Array.isArray(casesOrConfig)) {
+      return this.branchPredicate(casesOrConfig);
+    }
+    return this.branchSelect(casesOrConfig);
+  }
+  branchPredicate(cases) {
+    const node = {
+      type: "step",
+      id: "branch:predicate",
+      execute: async (state) => {
+        const ctx = state.ctx;
+        const input = state.output;
+        for (const branchCase of cases) {
+          if (branchCase.when) {
+            const match = await branchCase.when({ ctx, input });
+            if (!match) continue;
+          }
+          await this.executeAgent(state, branchCase.agent, ctx, branchCase);
+          return;
+        }
+        throw new WorkflowBranchError("predicate", `No branch matched and no default branch (a case without \`when\`) was provided. Input: ${JSON.stringify(input)}`);
+      }
+    };
+    return new _Workflow([...this.steps, node], this.id);
+  }
+  branchSelect(config) {
+    const node = {
+      type: "step",
+      id: "branch:select",
+      execute: async (state) => {
+        const ctx = state.ctx;
+        const input = state.output;
+        const key = await config.select({ ctx, input });
+        let agent = config.agents[key];
+        if (!agent) {
+          if (config.fallback) {
+            agent = config.fallback;
+          } else {
+            throw new WorkflowBranchError("select", `No agent found for key "${key}" and no fallback provided. Available keys: ${Object.keys(config.agents).join(", ")}`);
+          }
+        }
+        await this.executeAgent(state, agent, ctx, config);
+      }
+    };
+    return new _Workflow([...this.steps, node], this.id);
+  }
+  // ── foreach: array iteration ─────────────────────────────────
+  foreach(target, options) {
+    const concurrency = options?.concurrency ?? 1;
+    const isWorkflow = target instanceof SealedWorkflow;
+    const id = isWorkflow ? target.id ?? "foreach" : `foreach:${target.id}`;
+    const node = {
+      type: "step",
+      id,
+      execute: async (state) => {
+        const items = state.output;
+        if (!Array.isArray(items)) {
+          throw new Error(`foreach "${id}": expected array input, got ${typeof items}`);
+        }
+        const ctx = state.ctx;
+        const results = new Array(items.length);
+        const executeItem = async (item, index) => {
+          const itemState = { ctx: state.ctx, output: item, mode: "generate" };
+          if (isWorkflow) {
+            await this.executeNestedWorkflow(itemState, target);
+          } else {
+            await this.executeAgent(itemState, target, ctx);
+          }
+          results[index] = itemState.output;
+        };
+        if (concurrency <= 1) {
+          for (let i = 0; i < items.length; i++) {
+            await executeItem(items[i], i);
+          }
+        } else {
+          for (let i = 0; i < items.length; i += concurrency) {
+            const batch = items.slice(i, i + concurrency);
+            await Promise.all(batch.map((item, j) => executeItem(item, i + j)));
+          }
+        }
+        state.output = results;
+      }
+    };
+    return new _Workflow([...this.steps, node], this.id);
+  }
+  // ── repeat: conditional loop ─────────────────────────────────
+  repeat(target, options) {
+    const maxIterations = options.maxIterations ?? 10;
+    const isWorkflow = target instanceof SealedWorkflow;
+    const id = isWorkflow ? target.id ?? "repeat" : `repeat:${target.id}`;
+    const predicate = options.until ?? (async (p) => !await options.while(p));
+    const node = {
+      type: "step",
+      id,
+      execute: async (state) => {
+        const ctx = state.ctx;
+        for (let i = 1; i <= maxIterations; i++) {
+          if (isWorkflow) {
+            await this.executeNestedWorkflow(state, target);
+          } else {
+            await this.executeAgent(state, target, ctx);
+          }
+          const done = await predicate({
+            output: state.output,
+            ctx,
+            iterations: i
+          });
+          if (done) return;
+        }
+        throw new WorkflowLoopError(maxIterations, maxIterations);
+      }
+    };
+    return new _Workflow([...this.steps, node], this.id);
+  }
+  // ── catch ─────────────────────────────────────────────────────
+  catch(id, fn) {
+    if (!this.steps.some((s) => s.type === "step")) {
+      throw new Error(`Workflow: catch("${id}") requires at least one preceding step.`);
+    }
+    const node = {
+      type: "catch",
+      id,
+      catchFn: fn
+    };
+    return new _Workflow([...this.steps, node], this.id);
+  }
+  // ── finally (terminal — returns sealed workflow) ──────────────
+  finally(id, fn) {
+    const node = {
+      type: "finally",
+      id,
+      execute: async (state) => {
+        await fn({ ctx: state.ctx });
+      }
+    };
+    return new SealedWorkflow([...this.steps, node], this.id);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Agent,
+  Workflow,
+  WorkflowBranchError,
+  WorkflowLoopError,
+  defineTool
+});
+//# sourceMappingURL=index.cjs.map