@anvia/core 1.1.1 → 1.2.0

package/dist/pipeline/index.js

@@ -1,810 +1,32 @@
 import {
-  observerSnapshot
-} from "../chunk-KSKST3KP.js";
+  Pipeline
+} from "../chunk-TIZGADU4.js";
+import "../chunk-ETYB5JO6.js";
+import "../chunk-EKZRAWBP.js";
 import {
-  AgentRunBlockedError
-} from "../chunk-AHLKV6KP.js";
-import {
-  mapWithConcurrency
-} from "../chunk-IZNOP6JG.js";
-import {
-  extract
-} from "../chunk-JTJU56ZV.js";
-import "../chunk-4UQALF5Y.js";
-import "../chunk-OI3LSMJG.js";
-import "../chunk-7JLAIN6E.js";
-import "../chunk-QGX73TSQ.js";
-import "../chunk-3XQGVDU5.js";
-import {
-  abortError,
-  throwIfAborted
-} from "../chunk-3RWESPUG.js";
-
-// src/pipeline/errors.ts
-var PipelineAgentSuspensionError = class extends Error {
-  constructor(result) {
-    super("Pipeline agent stage suspended for human interaction.");
-    this.result = result;
-    this.name = "PipelineAgentSuspensionError";
-  }
-  result;
-};
-var PipelineObserverDispatchError = class extends AggregateError {
-  phase;
-  failures;
-  constructor(phase, failures) {
-    super(
-      failures.map((failure) => failure.error),
-      `Pipeline observer ${phase} failed for ${failures.map((failure) => failure.observer).join(", ")}.`
-    );
-    this.name = "PipelineObserverDispatchError";
-    this.phase = phase;
-    this.failures = Object.freeze([...failures]);
-  }
-};
-
-// src/pipeline/pipeline.ts
-import { z } from "zod";
-
-// src/pipeline/graph.ts
-var INPUT_ID = "$input";
-var OUTPUT_ID = "$output";
-var RESERVED_STAGE_IDS = /* @__PURE__ */ new Set([INPUT_ID, OUTPUT_ID]);
-function initialPipelineState(options) {
-  const input = graphNode(INPUT_ID, [INPUT_ID], "input", "Input");
-  const graph = {
-    id: options.id,
-    nodes: [input],
-    edges: []
-  };
-  if (options.name !== void 0) graph.name = options.name;
-  if (options.description !== void 0) graph.description = options.description;
-  if (options.metadata !== void 0) graph.metadata = options.metadata;
-  return {
-    graph,
-    terminalPaths: [input.path],
-    stageIds: /* @__PURE__ */ new Set(),
-    nextEdgeIndex: 1
-  };
-}
-function appendStageNode(state, kind, stage, options = {}) {
-  const id = validateStageId(stage.id);
-  if (state.stageIds.has(id)) {
-    throw new TypeError(`Pipeline stage id "${id}" is already registered.`);
-  }
-  const node = graphNode(id, [id], kind, stage.name ?? options.defaultLabel ?? id, {
-    description: stage.description,
-    metadata: stage.metadata,
-    agentId: options.agentId,
-    agentName: options.agentName,
-    pipelineId: options.pipelineId
-  });
-  return {
-    node,
-    state: appendNode(state, node, state.terminalPaths, [node.path], id)
-  };
-}
-function appendComposedGraph(state, boundary, child) {
-  return appendChildGraph(state, boundary.path, child);
-}
-function appendParallelBranch(state, parallel, branchKey, child) {
-  const id = validateStageId(branchKey);
-  const path = [...parallel.path, id];
-  const node = graphNode(id, path, "branch", id, { branchKey: id, pipelineId: child.id });
-  const withBranch = appendNode(state, node, [parallel.path], state.terminalPaths);
-  const withChild = appendChildGraph(withBranch, node.path, child);
-  return { state: withChild, node, terminalPaths: withChild.terminalPaths };
-}
-function withTerminalPaths(state, terminalPaths) {
-  return { ...state, terminalPaths };
-}
-function withOutputNode(state) {
-  const graph = cloneGraph(state.graph);
-  const outputPath = [OUTPUT_ID];
-  if (graph.nodes.some((node) => pathEquals(node.path, outputPath))) {
-    return graph;
-  }
-  graph.nodes.push(graphNode(OUTPUT_ID, outputPath, "output", "Output"));
-  graph.edges.push(
-    ...state.terminalPaths.map((source, index) => ({
-      id: `edge_${state.nextEdgeIndex + index}`,
-      source: [...source],
-      target: outputPath
-    }))
-  );
-  return graph;
-}
-function cloneGraph(graph) {
-  return {
-    ...graph,
-    nodes: graph.nodes.map((node) => ({ ...node, path: [...node.path] })),
-    edges: graph.edges.map((edge) => ({
-      ...edge,
-      source: [...edge.source],
-      target: [...edge.target]
-    }))
-  };
-}
-function scopedNode(node, path) {
-  return { ...node, path: [...path] };
-}
-function appendChildGraph(state, parentPath, child) {
-  const childNodes = child.nodes.filter((node) => !isBoundaryPath(node.path)).map((node) => scopedNode(node, [...parentPath, ...node.path]));
-  const childEdges = [];
-  const terminalPaths = [];
-  let nextEdgeIndex = state.nextEdgeIndex;
-  for (const edge of child.edges) {
-    const sourceIsInput = isInputPath(edge.source);
-    const targetIsOutput = isOutputPath(edge.target);
-    const source = sourceIsInput ? [...parentPath] : [...parentPath, ...edge.source];
-    if (targetIsOutput) {
-      terminalPaths.push(source);
-      continue;
-    }
-    const target = [...parentPath, ...edge.target];
-    let childEdge = {
-      id: `edge_${nextEdgeIndex}`,
-      source,
-      target
-    };
-    if (edge.label !== void 0) childEdge = { ...childEdge, label: edge.label };
-    childEdges.push(childEdge);
-    nextEdgeIndex += 1;
-  }
-  return {
-    ...state,
-    graph: {
-      ...state.graph,
-      nodes: [...state.graph.nodes, ...childNodes],
-      edges: [...state.graph.edges, ...childEdges]
-    },
-    terminalPaths: terminalPaths.length === 0 ? [[...parentPath]] : terminalPaths,
-    nextEdgeIndex
-  };
-}
-function appendNode(state, node, sourcePaths, terminalPaths, stageId) {
-  const edges = sourcePaths.map((source, index) => ({
-    id: `edge_${state.nextEdgeIndex + index}`,
-    source: [...source],
-    target: [...node.path]
-  }));
-  const stageIds = new Set(state.stageIds);
-  if (stageId !== void 0) stageIds.add(stageId);
-  return {
-    graph: {
-      ...state.graph,
-      nodes: [...state.graph.nodes, node],
-      edges: [...state.graph.edges, ...edges]
-    },
-    terminalPaths,
-    stageIds,
-    nextEdgeIndex: state.nextEdgeIndex + edges.length
-  };
-}
-function graphNode(id, path, kind, label, options = {}) {
-  const node = { id, path: [...path], kind, label };
-  if (options.description !== void 0) node.description = options.description;
-  if (options.metadata !== void 0) node.metadata = options.metadata;
-  if (options.agentId !== void 0) node.agentId = options.agentId;
-  if (options.agentName !== void 0) node.agentName = options.agentName;
-  if (options.pipelineId !== void 0) node.pipelineId = options.pipelineId;
-  if (options.branchKey !== void 0) node.branchKey = options.branchKey;
-  return node;
-}
-function validateStageId(value) {
-  if (typeof value !== "string") {
-    throw new TypeError("Pipeline stage id must be a string.");
-  }
-  const id = value.trim();
-  if (id.length === 0) {
-    throw new TypeError("Pipeline stage id must be a non-empty string.");
-  }
-  if (RESERVED_STAGE_IDS.has(id)) {
-    throw new TypeError(`Pipeline stage id "${id}" is reserved.`);
-  }
-  return id;
-}
-function isBoundaryPath(path) {
-  return isInputPath(path) || isOutputPath(path);
-}
-function isInputPath(path) {
-  return path.length === 1 && path[0] === INPUT_ID;
-}
-function isOutputPath(path) {
-  return path.length === 1 && path[0] === OUTPUT_ID;
-}
-function pathEquals(left, right) {
-  return left.length === right.length && left.every((segment, index) => segment === right[index]);
-}
-
-// src/pipeline/observability.ts
-function resolvePrimaryTrace(observers, primaryTrace) {
-  if (primaryTrace === void 0) return void 0;
-  const primary = observers.find((entry) => entry.name === primaryTrace);
-  return primary?.observer.trace === void 0 ? void 0 : Object.freeze({ observer: primary.name, ...primary.observer.trace });
-}
-function snapshotPipelineObservability(observability) {
-  if (observability === void 0) return void 0;
-  const observers = {};
-  for (const [name, observer] of Object.entries(observability.observers)) {
-    if (name.trim().length === 0) {
-      throw new TypeError("Pipeline observer names must not be empty.");
-    }
-    if (typeof observer !== "object" || observer === null || typeof observer.startRun !== "function") {
-      throw new TypeError(`Pipeline observer "${name}" must implement startRun().`);
-    }
-    observers[name] = observer;
-  }
-  if (observability.primaryTrace !== void 0 && !(observability.primaryTrace in observers)) {
-    throw new TypeError(
-      `Pipeline primaryTrace "${observability.primaryTrace}" must name a configured observer.`
-    );
-  }
-  const errorPolicy = observability.errorPolicy ?? "ignore";
-  if (errorPolicy !== "ignore" && errorPolicy !== "throw") {
-    throw new TypeError('Pipeline observability.errorPolicy must be "ignore" or "throw".');
-  }
-  const snapshot = {
-    observers: Object.freeze(observers),
-    errorPolicy,
-    ...observability.primaryTrace === void 0 ? {} : { primaryTrace: observability.primaryTrace }
-  };
-  return Object.freeze(snapshot);
-}
-async function startPipelineRunObservers(observers, args, options) {
-  const runObservers = [];
-  const failures = [];
-  for (const [name, observer] of Object.entries(observers)) {
-    try {
-      const runObserver = await observer.startRun(observerSnapshot(args));
-      if (runObserver !== void 0) {
-        runObservers.push({ name, observer: runObserver, terminal: false });
-      }
-    } catch (error) {
-      failures.push({ observer: name, error });
-    }
-  }
-  if (options.errorPolicy === "throw" && failures.length > 0) {
-    const startupError = new PipelineObserverDispatchError("startRun", failures);
-    const cleanupFailures = await terminateObservers(
-      runObservers,
-      (observer) => observer.error?.(
-        observerSnapshot({
-          runId: args.runId,
-          pipelineId: args.pipelineId,
-          status: "failed",
-          error: startupError,
-          durationMs: 0
-        })
-      )
-    );
-    throw new PipelineObserverDispatchError("startRun", [...failures, ...cleanupFailures]);
-  }
-  return new ActivePipelineRunObservers(runObservers, options);
-}
-var ActivePipelineRunObservers = class {
-  constructor(observers, options) {
-    this.observers = observers;
-    this.options = options;
-    this.trace = resolvePrimaryTrace(observers, options.primaryTrace);
-  }
-  observers;
-  options;
-  trace;
-  async startStage(args) {
-    const stageObservers = [];
-    const failures = [];
-    for (const entry of this.observers) {
-      if (entry.observer.startStage === void 0) continue;
-      try {
-        const observer = await entry.observer.startStage(observerSnapshot(args));
-        if (observer !== void 0) {
-          stageObservers.push({ name: entry.name, observer, terminal: false });
-        }
-      } catch (error) {
-        failures.push({ observer: entry.name, error });
-      }
-    }
-    if (this.options.errorPolicy === "throw" && failures.length > 0) {
-      const startupError = new PipelineObserverDispatchError("startStage", failures);
-      const cleanupFailures = await terminateObservers(
-        stageObservers,
-        (observer) => observer.error?.(observerSnapshot({ ...args, error: startupError, durationMs: 0 }))
-      );
-      throw new PipelineObserverDispatchError("startStage", [...failures, ...cleanupFailures]);
-    }
-    return new ActivePipelineStageObservers(stageObservers, this.options);
-  }
-  async end(args) {
-    await dispatchTerminalObservers(
-      this.observers,
-      "end",
-      (observer) => observer.end(observerSnapshot(args)),
-      this.options.errorPolicy
-    );
-  }
-  async error(args) {
-    await dispatchTerminalObservers(
-      this.observers,
-      "error",
-      (observer) => observer.error?.(observerSnapshot(args)),
-      "ignore"
-    );
-  }
-};
-var ActivePipelineStageObservers = class {
-  constructor(observers, options) {
-    this.observers = observers;
-    this.options = options;
-    this.trace = resolvePrimaryTrace(observers, options.primaryTrace);
-  }
-  observers;
-  options;
-  trace;
-  async end(args) {
-    await dispatchTerminalObservers(
-      this.observers,
-      "stage.end",
-      (observer) => observer.end(observerSnapshot(args)),
-      this.options.errorPolicy
-    );
-  }
-  async error(args) {
-    await dispatchTerminalObservers(
-      this.observers,
-      "stage.error",
-      (observer) => observer.error?.(observerSnapshot(args)),
-      "ignore"
-    );
-  }
-};
-async function dispatchTerminalObservers(observers, phase, dispatch, errorPolicy) {
-  const failures = await terminateObservers(observers, dispatch);
-  if (errorPolicy === "throw" && failures.length > 0) {
-    throw new PipelineObserverDispatchError(phase, failures);
-  }
-}
-async function terminateObservers(observers, dispatch) {
-  const failures = [];
-  for (const entry of observers) {
-    if (entry.terminal) continue;
-    entry.terminal = true;
-    try {
-      await dispatch(entry.observer);
-    } catch (error) {
-      failures.push({ observer: entry.name, error });
-    }
-  }
-  return failures;
-}
-
-// src/pipeline/runtime.ts
-async function runNode(context, node, path, input, fn) {
-  throwIfAborted(context.abortSignal);
-  const eventNode = scopedNode(node, path);
-  const startedAt = Date.now();
-  const eventBase = {
-    runId: context.runId,
-    pipelineId: context.pipelineId,
-    path: [...path],
-    node: eventNode
-  };
-  const observers = await context.observability.startStage({ ...eventBase, input });
-  try {
-    await emitEvent(context, { type: "stage_started", ...eventBase });
-  } catch (error) {
-    await observers.error({ ...eventBase, error, durationMs: Date.now() - startedAt });
-    throw error;
-  }
-  try {
-    const output = await fn(observers.trace);
-    throwIfAborted(context.abortSignal);
-    const durationMs = Date.now() - startedAt;
-    await emitEvent(context, {
-      type: "stage_completed",
-      ...eventBase,
-      durationMs
-    });
-    await observers.end({ ...eventBase, output, durationMs });
-    return output;
-  } catch (error) {
-    const durationMs = Date.now() - startedAt;
-    const failureEvent = {
-      type: "stage_failed",
-      ...eventBase,
-      durationMs,
-      error
-    };
-    try {
-      await emitEvent(context, failureEvent);
-    } catch (observerError) {
-      await observers.error({ ...eventBase, error, durationMs });
-      throw new AggregateError(
-        [error, observerError],
-        `Pipeline stage "${node.id}" and its observer both failed.`
-      );
-    }
-    await observers.error({ ...eventBase, error, durationMs });
-    throw error;
-  }
-}
-function stageContext(input, context) {
-  return {
-    input,
-    runId: context.runId,
-    pipelineId: context.pipelineId,
-    runMetadata: context.runMetadata,
-    abortSignal: context.abortSignal
-  };
-}
-function childContext(context, abortSignal) {
-  return { ...context, abortSignal };
-}
-function combineAbortSignals(parent, local) {
-  const controller = new AbortController();
-  const abortFromParent = () => controller.abort(parent?.reason);
-  const abortFromLocal = () => controller.abort(local.reason);
-  if (parent?.aborted === true) {
-    controller.abort(parent.reason);
-  } else if (local.aborted) {
-    controller.abort(local.reason);
-  } else {
-    parent?.addEventListener("abort", abortFromParent, { once: true });
-    local.addEventListener("abort", abortFromLocal, { once: true });
-  }
-  return {
-    signal: controller.signal,
-    dispose() {
-      parent?.removeEventListener("abort", abortFromParent);
-      local.removeEventListener("abort", abortFromLocal);
-    }
-  };
-}
-function pipelineAbortError(signal) {
-  return abortError(signal?.reason);
-}
-async function emitEvent(context, event) {
-  if (context.observer === void 0) return;
-  try {
-    await context.observer.onEvent(event);
-  } catch (error) {
-    if (context.failOnObserverError) throw error;
-  }
-}
-
-// src/pipeline/pipeline.ts
-var internalPipelineOptions = /* @__PURE__ */ Symbol("internal-pipeline-options");
-var Pipeline = class {
-  id;
-  name;
-  description;
-  metadata;
-  observability;
-  executor;
-  state;
-  constructor(options) {
-    if (isInternalPipelineOptions(options)) {
-      this.executor = options[internalPipelineOptions].executor;
-      this.state = options[internalPipelineOptions].state;
-      this.observability = options[internalPipelineOptions].observability;
-    } else {
-      const id = normalizePipelineId(options.id);
-      if (!isZodSchema(options.inputSchema)) {
-        throw new TypeError("Pipeline inputSchema must be a Zod schema.");
-      }
-      const inputSchema = options.inputSchema;
-      this.executor = (async (input, context) => {
-        throwIfAborted(context.abortSignal);
-        return inputSchema.parseAsync(input);
-      });
-      this.state = initialPipelineState({
-        id,
-        name: options.name,
-        description: options.description,
-        metadata: options.metadata
-      });
-      this.observability = snapshotPipelineObservability(options.observability);
-    }
-    const graph = this.state.graph;
-    this.id = graph.id;
-    this.name = graph.name;
-    this.description = graph.description;
-    this.metadata = graph.metadata;
-  }
-  step(options) {
-    const next = appendStageNode(this.state, "step", options);
-    const executor = (async (input, context, pathPrefix) => {
-      const value = await this.execute(input, context, pathPrefix);
-      const path = [...pathPrefix, next.node.id];
-      return await runNode(
-        context,
-        next.node,
-        path,
-        value,
-        () => options.run(stageContext(value, context))
-      );
-    });
-    return this.derive(executor, next.state);
-  }
-  compose(options) {
-    const boundary = appendStageNode(this.state, "pipeline", options, {
-      defaultLabel: options.pipeline.name ?? options.pipeline.id,
-      pipelineId: options.pipeline.id
-    });
-    const state = appendComposedGraph(boundary.state, boundary.node, options.pipeline.graph());
-    const executor = (async (input, context, pathPrefix) => {
-      const value = await this.execute(input, context, pathPrefix);
-      const path = [...pathPrefix, boundary.node.id];
-      return await runNode(
-        context,
-        boundary.node,
-        path,
-        value,
-        () => options.pipeline.execute(value, context, path)
-      );
-    });
-    return this.derive(executor, state);
-  }
-  parallel(options) {
-    const branchEntries = normalizeParallelBranches(options.branches);
-    if (branchEntries.length === 0) {
-      throw new TypeError("Pipeline parallel branches must not be empty.");
-    }
-    const parallel = appendStageNode(this.state, "parallel", options, {
-      defaultLabel: `${branchEntries.length} parallel branches`
-    });
-    let nextState = parallel.state;
-    const branchNodes = /* @__PURE__ */ new Map();
-    const terminalPaths = [];
-    for (const [key, branch] of branchEntries) {
-      const appended = appendParallelBranch(nextState, parallel.node, key, branch.graph());
-      nextState = appended.state;
-      branchNodes.set(key, appended.node);
-      terminalPaths.push(...appended.terminalPaths);
-    }
-    nextState = withTerminalPaths(nextState, terminalPaths);
-    return this.derive(async (input, context, pathPrefix) => {
-      const value = await this.execute(input, context, pathPrefix);
-      const parallelPath = [...pathPrefix, parallel.node.id];
-      return runNode(context, parallel.node, parallelPath, value, async () => {
-        const controller = new AbortController();
-        const combined = combineAbortSignals(context.abortSignal, controller.signal);
-        const branchContext = childContext(context, combined.signal);
-        let firstError;
-        const promises = branchEntries.map(async ([key, branch]) => {
-          const node = branchNodes.get(key);
-          const path = [...parallelPath, node.id];
-          try {
-            const output = await runNode(
-              branchContext,
-              node,
-              path,
-              value,
-              () => branch.execute(value, branchContext, path)
-            );
-            return [key, output];
-          } catch (error) {
-            if (firstError === void 0) firstError = error;
-            if (!controller.signal.aborted) controller.abort(error);
-            throw error;
-          }
-        });
-        const settled = await Promise.allSettled(promises);
-        combined.dispose();
-        if (context.abortSignal?.aborted === true) {
-          throw pipelineAbortError(context.abortSignal);
-        }
-        if (firstError !== void 0) throw firstError;
-        return Object.fromEntries(
-          settled.map(
-            (result) => result.value
-          )
-        );
-      });
-    }, nextState);
-  }
-  agent(options) {
-    if (options.suspension !== "reject") {
-      throw new TypeError('Pipeline Agent stages require suspension: "reject".');
-    }
-    const next = appendStageNode(this.state, "agent", options, {
-      defaultLabel: options.agent.name ?? options.agent.id,
-      agentId: options.agent.id,
-      agentName: options.agent.name
-    });
-    return this.derive(async (input, context, pathPrefix) => {
-      const value = await this.execute(input, context, pathPrefix);
-      const path = [...pathPrefix, next.node.id];
-      return runNode(context, next.node, path, value, async (stageTrace) => {
-        const request = await options.request(stageContext(value, context));
-        const response = await options.agent.generate({
-          ...request,
-          trace: withPipelineParentTrace(
-            request.trace,
-            stageTrace,
-            options.agent.observability?.primaryTrace
-          ),
-          abortSignal: context.abortSignal
-        });
-        if (response.type === "interaction") {
-          throw new PipelineAgentSuspensionError(response);
-        }
-        if (response.type === "blocked") {
-          throw new AgentRunBlockedError(response);
-        }
-        return response.output;
-      });
-    }, next.state);
-  }
-  extract(options) {
-    const next = appendStageNode(this.state, "extractor", options);
-    return this.derive(async (input, context, pathPrefix) => {
-      const value = await this.execute(input, context, pathPrefix);
-      const path = [...pathPrefix, next.node.id];
-      return runNode(context, next.node, path, value, async () => {
-        const text = await options.text(stageContext(value, context));
-        const result = await extract({
-          model: options.model,
-          text,
-          outputSchema: options.outputSchema,
-          instructions: options.instructions,
-          retries: options.retries,
-          temperature: options.temperature,
-          maxTokens: options.maxTokens,
-          providerOptions: options.providerOptions,
-          abortSignal: context.abortSignal
-        });
-        return result.output;
-      });
-    }, next.state);
-  }
-  async run(options) {
-    const runId = normalizeRunId(options.runId ?? globalThis.crypto.randomUUID());
-    const startedAt = Date.now();
-    const observability = await startPipelineRunObservers(
-      this.observability?.observers ?? {},
-      {
-        runId,
-        pipelineId: this.id,
-        pipelineName: this.name,
-        pipelineDescription: this.description,
-        pipelineMetadata: this.metadata,
-        runMetadata: options.metadata,
-        trace: options.trace,
-        input: options.input
-      },
-      {
-        primaryTrace: this.observability?.primaryTrace,
-        errorPolicy: this.observability?.errorPolicy ?? "ignore"
-      }
-    );
-    const context = {
-      runId,
-      pipelineId: this.id,
-      runMetadata: options.metadata,
-      abortSignal: options.abortSignal,
-      observer: options.observer,
-      failOnObserverError: options.failOnObserverError === true,
-      observability
-    };
-    try {
-      throwIfAborted(context.abortSignal);
-      const output = await this.execute(options.input, context, []);
-      throwIfAborted(context.abortSignal);
-      await observability.end({
-        runId,
-        pipelineId: this.id,
-        output,
-        durationMs: Date.now() - startedAt
-      });
-      return observability.trace === void 0 ? { runId, output } : { runId, output, trace: observability.trace };
-    } catch (error) {
-      await observability.error({
-        runId,
-        pipelineId: this.id,
-        status: context.abortSignal?.aborted === true ? "cancelled" : "failed",
-        error,
-        durationMs: Date.now() - startedAt
-      });
-      throw error;
-    }
-  }
-  async runBatch(options) {
-    throwIfAborted(options.abortSignal);
-    return mapWithConcurrency([...options.inputs], options.concurrency, async (input) => {
-      const runId = globalThis.crypto.randomUUID();
-      try {
-        const result = await this.run({
-          input,
-          runId,
-          metadata: options.metadata,
-          trace: options.trace,
-          abortSignal: options.abortSignal,
-          observer: options.observer,
-          failOnObserverError: options.failOnObserverError
-        });
-        return { status: "completed", ...result };
-      } catch (error) {
-        if (options.abortSignal?.aborted === true) {
-          throw pipelineAbortError(options.abortSignal);
-        }
-        return { status: "failed", runId, error };
-      }
-    });
-  }
-  graph() {
-    return cloneGraph(withOutputNode(this.state));
-  }
-  derive(executor, state) {
-    return createDerivedPipeline(executor, state, this.observability);
-  }
-  async execute(input, context, pathPrefix) {
-    throwIfAborted(context.abortSignal);
-    return await this.executor(input, context, pathPrefix);
-  }
-};
-function createDerivedPipeline(executor, state, observability) {
-  const options = {
-    [internalPipelineOptions]: { executor, state, observability }
-  };
-  return new Pipeline(options);
-}
-function withPipelineParentTrace(trace, parent, agentPrimaryTrace) {
-  if (parent?.traceId === void 0) return trace;
-  if (parent.observer !== agentPrimaryTrace) return trace;
-  if (trace?.traceId !== void 0 && trace.traceId !== parent.traceId) return trace;
-  return {
-    ...trace,
-    traceId: parent.traceId,
-    ...trace?.parentObservationId !== void 0 || parent.observationId === void 0 ? {} : { parentObservationId: parent.observationId }
-  };
-}
-function isInternalPipelineOptions(options) {
-  return internalPipelineOptions in options;
-}
-function isZodSchema(value) {
-  return value instanceof z.ZodType;
-}
-function normalizePipelineId(id) {
-  if (typeof id !== "string") {
-    throw new TypeError("Pipeline id must be a string.");
-  }
-  const normalized = id.trim();
-  if (normalized.length === 0) {
-    throw new TypeError("Pipeline id must be a non-empty string.");
-  }
-  return normalized;
-}
-function normalizeRunId(runId) {
-  if (typeof runId !== "string") {
-    throw new TypeError("Pipeline runId must be a string.");
-  }
-  const normalized = runId.trim();
-  if (normalized.length === 0) {
-    throw new TypeError("Pipeline runId must be a non-empty string.");
-  }
-  return normalized;
-}
-function normalizeParallelBranches(branches) {
-  const entries = [];
-  const ids = /* @__PURE__ */ new Set();
-  for (const key of Object.keys(branches)) {
-    const pipeline = branches[key];
-    const id = key.trim();
-    if (id.length === 0) {
-      throw new TypeError("Pipeline parallel branch id must be a non-empty string.");
-    }
-    if (ids.has(id)) {
-      throw new TypeError(`Pipeline parallel branch id "${id}" is already registered.`);
-    }
-    ids.add(id);
-    if (id !== key) {
-      throw new TypeError("Pipeline parallel branch ids must not contain surrounding whitespace.");
-    }
-    entries.push([id, pipeline]);
-  }
-  return entries;
-}
+  PipelineAgentSuspensionError,
+  PipelineObserverDispatchError
+} from "../chunk-R6722CIU.js";
+import "../chunk-V3FFZWF3.js";
+import "../chunk-3P3YVJ7V.js";
+import "../chunk-UOGM62JL.js";
+import "../chunk-H3H74RWJ.js";
+import "../chunk-TP3MCUXS.js";
+import "../chunk-6RQYWZI3.js";
+import "../chunk-NF6WBPFG.js";
+import "../chunk-4FIVU53H.js";
+import "../chunk-BDKFFFVX.js";
+import "../chunk-CKKNO4XB.js";
+import "../chunk-4ONUNWGC.js";
+import "../chunk-UTAB3XQI.js";
+import "../chunk-XQV3XNVT.js";
+import "../chunk-IDNL6IH4.js";
+import "../chunk-BONQTXRQ.js";
+import "../chunk-4C7AXYOM.js";
+import "../chunk-SQAAVYJG.js";
+import "../chunk-POXHJF3H.js";
+import "../chunk-USRKPEQN.js";
+import "../chunk-WN6AVBO4.js";
 export {
   Pipeline,
   PipelineAgentSuspensionError,