@geoscene/ai-components 0.0.0-stage → 5.1.14

package/dist/agent-utils/workflows/BaseWorkflow.d.ts

@@ -0,0 +1,87 @@
+import type Accessor from "@geoscene/core/core/Accessor.js";
+import type { AgentCreateGraph, AgentData, AgentGraphState, AgentStateAnnotation, BaseAgentLike, GraphEdge, GraphNodes } from "../types.js";
+
+/**
+ * Return payload from `BaseWorkflow.generate()`.
+ *
+ * @since 5.1
+ */
+export type WorkflowGenerateResult<TState extends AgentData = AgentData> = {
+  /**
+   * Shared workflow state annotation.
+   *
+   * @since 5.1
+   */
+  workspace: AgentStateAnnotation<TState>;
+  /**
+   * Factory that creates the workflow graph.
+   *
+   * @since 5.1
+   */
+  createGraph: AgentCreateGraph<TState>;
+};
+
+/**
+ * BaseWorkflow is the foundational class for defining workflows. A workflow defines a sequence of
+ * agents that work together to accomplish a task. This class provides the structure and common
+ * building blocks for constructing a workflow, including generating the shared workspace and
+ * creating the graph that defines how agents are connected and executed.
+ *
+ * Specific workflows extend this base class and implement the abstract methods to define
+ * their unique behavior and structure.
+ *
+ * The following workflow types are supported:
+ *
+ * - `SequentialWorkflow` - executes agents in a sequence, where the output of one agent can be passed as input to the next.
+ * - `ConditionalWorkflow` - allows for branching logic based on conditions evaluated at runtime, enabling different paths of execution depending on user input or LLM output.
+ * - `LoopWorkflow` - supports repeating a set of agents until a certain condition is met, useful for iterative processes.
+ * - `ParallelWorkflow` - enables concurrent execution of multiple agents, allowing for tasks that can be performed simultaneously.
+ * - `RouterWorkflow` - dynamically routes execution to different agents based on the input or state, providing flexibility in handling various scenarios.
+ * - `SwitchWorkflow` - similar to RouterWorkflow but designed for cases where there are multiple distinct paths based on discrete values in the input or state.
+ *
+ * @since 5.1
+ */
+export abstract class BaseWorkflow<TState extends AgentData = AgentData> extends Accessor {
+  /**
+   * Builds the workflow-specific edges.
+   *
+   * @param agents
+   */
+  protected abstract buildEdges(agents: BaseAgentLike<TState>[]): GraphEdge<AgentGraphState<TState>>[];
+  /**
+   * Builds the workflow's graph nodes.
+   *
+   * Node ids use the agent id plus its position (`agent.id_index`) instead of only the raw
+   * agent id. That prevents collisions when the same agent instance is used multiple times.
+   *
+   * @param agents
+   */
+  protected buildNodes(agents: BaseAgentLike<TState>[]): GraphNodes<AgentGraphState<TState>>;
+  /**
+   * Generates the workflow's graph and shared workspace based on the defined agents and their schemas. This method is
+   * called by the WorkflowAgent when it generates its graph, and it orchestrates the creation of the workflow's structure,
+   * including validating the agents, deriving shared state from their schemas, and building the nodes and edges of the graph.
+   */
+  generate(): WorkflowGenerateResult<TState>;
+  /** A list of agents that are part of this workflow. */
+  abstract getAgents(): BaseAgentLike<TState>[];
+  /**
+   * Returns the id of the first node in the workflow graph.
+   *
+   * @param agents
+   */
+  protected abstract getEntryNode(agents: BaseAgentLike<TState>[]): string | undefined;
+  /**
+   * Returns whether the agent at this position should expose terminal runtime fields.
+   *
+   * @param agents
+   * @param index
+   */
+  protected abstract isTerminalAgent(agents: BaseAgentLike<TState>[], index: number): boolean;
+  /**
+   * Validates the workflow configuration and throws if invalid.
+   *
+   * @param agents
+   */
+  protected validateAgents(agents: BaseAgentLike<TState>[]): void;
+}

package/dist/agent-utils/workflows/ConditionalWorkflow.d.ts

@@ -0,0 +1,72 @@
+import type { AgentData, AgentExecutionConfig, AgentGraphState, BaseAgentLike, GraphEdge, GraphNodes } from "../types.js";
+import type { BaseWorkflow } from "./BaseWorkflow.js";
+
+/**
+ * Condition function that routes execution to either the true branch or false branch.
+ *
+ * @param state - Current workflow graph state.
+ * @param config - Optional execution configuration.
+ * @since 5.1
+ */
+export type ConditionDecider<TState extends AgentData = AgentData> = (state: AgentGraphState<TState>, config?: AgentExecutionConfig) => Promise<boolean> | boolean;
+
+/**
+ * ConditionalWorkflow chooses between two branch agents based on a boolean condition and
+ * routes execution through a simple true/false branch.
+ *
+ * Use when:
+ * - you want an if/else style decision or
+ * - only two branches are needed.
+ *
+ * How it works:
+ * - evaluate `condition(state, config)`,
+ * - if true, run the first branch agent,
+ * - if false, run the second branch agent.
+ *
+ * @since 5.1
+ */
+export class ConditionalWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
+  constructor(properties: ConditionalWorkflowConstructProperties<TState>);
+  /**
+   * Must contain exactly two agents: `[trueAgent, falseAgent]`. The first agent is executed when
+   * the condition is true, the second when the condition is false.
+   *
+   * @required
+   */
+  accessor agents: BaseAgentLike<TState>[];
+  /**
+   * Predicate that chooses the next branch.
+   *
+   * @required
+   */
+  accessor condition: ConditionDecider<TState>;
+  /**
+   * Builds the workflow-specific edges.
+   *
+   * @param agents
+   */
+  protected buildEdges(agents: BaseAgentLike<TState>[]): GraphEdge<AgentGraphState<TState>>[];
+  /**
+   * Builds the workflow's graph nodes.
+   *
+   * Node ids use the agent id plus its position (`agent.id_index`) instead of only the raw
+   * agent id. That prevents collisions when the same agent instance is used multiple times.
+   *
+   * @param agents
+   */
+  protected buildNodes(agents: BaseAgentLike<TState>[]): GraphNodes<AgentGraphState<TState>>;
+  /** A list of agents that are part of this workflow. */
+  getAgents(): BaseAgentLike<TState>[];
+  /** Returns the id of the first node in the workflow graph. */
+  protected getEntryNode(): string;
+  /** Returns whether the agent at this position should expose terminal runtime fields. */
+  protected isTerminalAgent(): boolean;
+  /**
+   * Validates the workflow configuration and throws if invalid.
+   *
+   * @param agents
+   */
+  protected validateAgents(agents: BaseAgentLike<TState>[]): void;
+}
+
+export type ConditionalWorkflowConstructProperties<TState extends AgentData> = Pick<ConditionalWorkflow<TState>, "agents" | "condition">;

package/dist/agent-utils/workflows/ConditionalWorkflow.js

@@ -0,0 +1,61 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+import { property as u, subclass as f } from "@geoscene/core/core/accessorSupport/decorators.js";
+import { B as p, g as c } from "../../chunks/BaseWorkflow.js";
+var g = Object.defineProperty, w = Object.getOwnPropertyDescriptor, a = (e, r, n, t) => {
+  for (var o = t > 1 ? void 0 : t ? w(r, n) : r, i = e.length - 1, s; i >= 0; i--)
+    (s = e[i]) && (o = (t ? s(r, n, o) : s(o)) || o);
+  return t && o && g(r, n, o), o;
+};
+let l = class extends p {
+  //#region Lifecycle
+  constructor(e) {
+    super(e);
+  }
+  //#endregion
+  //#region Public Methods
+  getAgents() {
+    return this.agents;
+  }
+  //#endregion
+  //#region Protected Methods
+  buildNodes(e) {
+    const r = super.buildNodes(e);
+    return r[d] = () => ({}), r;
+  }
+  buildEdges(e) {
+    const r = this.condition;
+    if (!r)
+      throw new Error("ConditionalWorkflow 必须提供条件。");
+    const n = c(e[0], 0), t = c(e[1], 1);
+    return [
+      {
+        from: d,
+        decide: async (o, i) => await Promise.resolve(r(o, i)) ? n : t
+      }
+    ];
+  }
+  getEntryNode() {
+    return d;
+  }
+  isTerminalAgent() {
+    return !0;
+  }
+  validateAgents(e) {
+    if (super.validateAgents(e), e.length !== 2)
+      throw new Error(`ConditionalWorkflow 必须且只能包含2个 Agent，实际为 ${e.length}.`);
+  }
+  //#endregion
+};
+a([
+  u()
+], l.prototype, "condition", 2);
+a([
+  u()
+], l.prototype, "agents", 2);
+l = a([
+  f("ConditionalWorkflow")
+], l);
+const d = "__conditional_decide";
+export {
+  l as ConditionalWorkflow
+};

package/dist/agent-utils/workflows/LoopWorkflow.d.ts

@@ -0,0 +1,58 @@
+import type { AgentData, AgentExecutionConfig, AgentGraphState, BaseAgentLike, GraphEdge } from "../types.js";
+import type { BaseWorkflow, WorkflowGenerateResult } from "./BaseWorkflow.js";
+
+/**
+ * Loop continuation predicate. Return true to run another iteration.
+ *
+ * @param state - Current workflow graph state.
+ * @param config - Optional execution configuration.
+ * @since 5.1
+ */
+export type LoopDecider<TState extends AgentData = AgentData> = (state: AgentGraphState<TState>, config?: AgentExecutionConfig) => Promise<boolean> | boolean;
+
+/**
+ * LoopWorkflow repeatedly executes an inner workflow until a stop condition is met.
+ *
+ * Use in the following scenarios:
+ *
+ * - You need retry/refine loops,
+ * - You want iterative planning and execution.
+ *
+ * How it works:
+ * - Runs the inner `workflow`,
+ * - Evaluates `decideContinue(state, config)`,
+ * - If true, runs again; if false (or unset), stops.
+ *
+ * @since 5.1
+ */
+export class LoopWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
+  constructor(properties: LoopWorkflowConstructProperties<TState>);
+  /**
+   * Function that decides whether the loop should continue.
+   *
+   * @required
+   */
+  accessor decideContinue: LoopDecider<TState>;
+  /**
+   * Inner workflow to execute on each loop iteration.
+   *
+   * @required
+   */
+  accessor workflow: BaseWorkflow<TState>;
+  /** Builds the workflow-specific edges. */
+  protected buildEdges(): GraphEdge<AgentGraphState<TState>>[];
+  /**
+   * Generates the workflow's graph and shared workspace based on the defined agents and their schemas. This method is
+   * called by the WorkflowAgent when it generates its graph, and it orchestrates the creation of the workflow's structure,
+   * including validating the agents, deriving shared state from their schemas, and building the nodes and edges of the graph.
+   */
+  generate(): WorkflowGenerateResult<TState>;
+  /** A list of agents that are part of this workflow. */
+  getAgents(): BaseAgentLike<TState>[];
+  /** Returns the id of the first node in the workflow graph. */
+  protected getEntryNode(): string;
+  /** Returns whether the agent at this position should expose terminal runtime fields. */
+  protected isTerminalAgent(): boolean;
+}
+
+export type LoopWorkflowConstructProperties<TState extends AgentData> = Pick<LoopWorkflow<TState>, "decideContinue" | "workflow">;

package/dist/agent-utils/workflows/LoopWorkflow.js

@@ -0,0 +1,56 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+import { property as u, subclass as w } from "@geoscene/core/core/accessorSupport/decorators.js";
+import { c as f } from "../../chunks/graph.js";
+import { B as h } from "../../chunks/BaseWorkflow.js";
+var g = Object.defineProperty, m = Object.getOwnPropertyDescriptor, d = (o, r, n, t) => {
+  for (var e = t > 1 ? void 0 : t ? m(r, n) : r, s = o.length - 1, c; s >= 0; s--)
+    (c = o[s]) && (e = (t ? c(r, n, e) : c(e)) || e);
+  return t && e && g(r, n, e), e;
+};
+let p = class extends h {
+  //#region Lifecycle
+  constructor(o) {
+    super(o);
+  }
+  //#endregion
+  //#region Public Methods
+  getAgents() {
+    return this.workflow.getAgents();
+  }
+  generate() {
+    const o = this.workflow.generate(), r = o.workspace, n = o.createGraph().compile(), { decideContinue: t } = this, e = {
+      [a]: async (i, l) => await n.invoke(i, l)
+    }, s = [
+      {
+        from: a,
+        decide: async (i, l) => await Promise.resolve(t(i, l)) ? a : void 0
+      }
+    ];
+    return { workspace: r, createGraph: () => f(e, s, r, { entryNode: a }) };
+  }
+  //#endregion
+  //#region Protected Methods
+  buildEdges() {
+    throw new Error("LoopWorkflow 已覆盖 generate()，不应调用 buildEdges。");
+  }
+  getEntryNode() {
+    return a;
+  }
+  isTerminalAgent() {
+    return !0;
+  }
+  //#endregion
+};
+d([
+  u()
+], p.prototype, "workflow", 2);
+d([
+  u()
+], p.prototype, "decideContinue", 2);
+p = d([
+  w("LoopWorkflow")
+], p);
+const a = "__loop_body";
+export {
+  p as LoopWorkflow
+};

package/dist/agent-utils/workflows/ParallelWorkflow.d.ts

@@ -0,0 +1,68 @@
+import type { AgentData, AgentGraphState, BaseAgentLike, GraphEdge, GraphNodes } from "../types.js";
+import type { BaseWorkflow, WorkflowGenerateResult } from "./BaseWorkflow.js";
+
+/**
+ * ParallelWorkflow fans out execution to multiple agents and merges branch outputs.
+ *
+ * Use in the following scenarios:
+ * - Branches can run independently from the same input,
+ * - You want fan-out/fan-in behavior.
+ *
+ * How it works:
+ * - Fan out - every agent receives the same input snapshot,
+ * - Each branch collects its result in a hidden state key,
+ * - Fan in - merge outputs in declared agent order.
+ *
+ * Merge rule:
+ * - If two branches set the same shared key to different values, an error is thrown,
+ * as this indicates a conflict the workflow cannot resolve on its own.
+ *
+ * @since 5.1
+ */
+export class ParallelWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
+  constructor(properties: ParallelWorkflowConstructProperties<TState>);
+  /**
+   * Agents to run in parallel from the same input snapshot.
+   *
+   * @required
+   */
+  accessor agents: BaseAgentLike<TState>[];
+  /**
+   * Builds the workflow-specific edges.
+   *
+   * @param agents
+   */
+  protected buildEdges(agents: BaseAgentLike<TState>[]): GraphEdge<AgentGraphState<TState>>[];
+  /**
+   * Builds the workflow's graph nodes.
+   *
+   * Node ids use the agent id plus its position (`agent.id_index`) instead of only the raw
+   * agent id. That prevents collisions when the same agent instance is used multiple times.
+   *
+   * @param agents
+   */
+  protected buildNodes(agents: BaseAgentLike<TState>[]): GraphNodes<AgentGraphState<TState>>;
+  /**
+   * Generates the workflow's graph and shared workspace based on the defined agents and their schemas. This method is
+   * called by the WorkflowAgent when it generates its graph, and it orchestrates the creation of the workflow's structure,
+   * including validating the agents, deriving shared state from their schemas, and building the nodes and edges of the graph.
+   */
+  generate(): WorkflowGenerateResult<TState>;
+  /** A list of agents that are part of this workflow. */
+  getAgents(): BaseAgentLike<TState>[];
+  /**
+   * Returns the id of the first node in the workflow graph.
+   *
+   * @param _agents
+   */
+  protected getEntryNode(_agents: BaseAgentLike<TState>[]): string;
+  /**
+   * Returns whether the agent at this position should expose terminal runtime fields.
+   *
+   * @param _agents
+   * @param _index
+   */
+  protected isTerminalAgent(_agents: BaseAgentLike<TState>[], _index: number): boolean;
+}
+
+export type ParallelWorkflowConstructProperties<TState extends AgentData> = Pick<ParallelWorkflow<TState>, "agents">;

package/dist/agent-utils/workflows/ParallelWorkflow.js

@@ -0,0 +1,129 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+import { property as A, subclass as I } from "@geoscene/core/core/accessorSupport/decorators.js";
+import { c as U } from "../../chunks/graph.js";
+import { a as W } from "../../chunks/state.js";
+import { B as G, c as J, g as m, a as j } from "../../chunks/BaseWorkflow.js";
+var k = Object.defineProperty, B = Object.getOwnPropertyDescriptor, C = (e, t, s, n) => {
+  for (var a = n > 1 ? void 0 : n ? B(t, s) : t, o = e.length - 1, r; o >= 0; o--)
+    (r = e[o]) && (a = (n ? r(t, s, a) : r(a)) || a);
+  return n && a && k(t, s, a), a;
+};
+let y = class extends G {
+  //#region Lifecycle
+  constructor(e) {
+    super(e);
+  }
+  //#endregion
+  //#region Public Methods
+  getAgents() {
+    return this.agents;
+  }
+  generate() {
+    const e = this.getAgents();
+    this.validateAgents(e);
+    for (const r of e)
+      r.generate();
+    const t = J(e.flatMap((r) => r.getSchemas()));
+    for (const [r] of e.entries())
+      t[_(r)] = void 0;
+    const s = W(t), n = this.buildNodes(e), a = this.buildEdges(e);
+    return { workspace: s, createGraph: () => U(n, a, s, { entryNode: this.getEntryNode(e) }) };
+  }
+  //#endregion
+  //#region Protected Methods
+  getEntryNode(e) {
+    return h;
+  }
+  isTerminalAgent(e, t) {
+    return !1;
+  }
+  buildNodes(e) {
+    const t = {};
+    for (const [s, n] of e.entries()) {
+      const a = _(s), o = m(n, s);
+      t[o] = async (r, i) => {
+        const d = await n.run(K(r, n), i), u = {}, f = u;
+        return f[a] = d, u;
+      };
+    }
+    return t[h] = () => ({}), t[w] = (s) => $(s, e), t;
+  }
+  buildEdges(e) {
+    return [
+      ...e.map((t, s) => ({ from: h, to: m(t, s) })),
+      ...e.map((t, s) => ({ from: m(t, s), to: w }))
+    ];
+  }
+  //#endregion
+};
+C([
+  A()
+], y.prototype, "agents", 2);
+y = C([
+  I("ParallelWorkflow")
+], y);
+const h = "__parallel_fanOut", w = "__parallel_join";
+function _(e) {
+  return `__parallel_update_${e}`;
+}
+function F(e, t) {
+  return Object.fromEntries(
+    t.filter((s) => Object.hasOwn(e, s)).map((s) => [s, e[s]])
+  );
+}
+function K(e, t) {
+  const s = t.inputSchema;
+  return s ? {
+    ...F(e, j(s)),
+    agentExecutionContext: e.agentExecutionContext,
+    outputMessage: e.outputMessage,
+    status: void 0,
+    summary: ""
+  } : { ...e, status: void 0, summary: "" };
+}
+function D(e, t) {
+  return e.outputSchema ? F(t, j(e.outputSchema)) : {};
+}
+function R(e, t) {
+  const s = e.agentExecutionContext?.messages ?? [], n = t.agentExecutionContext?.messages ?? [];
+  return n.length > s.length ? n.slice(s.length) : void 0;
+}
+function $(e, t) {
+  const s = [], n = [], a = [], o = {}, r = {}, i = /* @__PURE__ */ new Set();
+  for (const [f, P] of t.entries()) {
+    const x = _(f), g = e[x];
+    if (r[x] = void 0, !g || typeof g != "object")
+      continue;
+    const c = g, S = c.outputMessage, b = R(e, c), v = c.summary, M = D(P, c), O = S.trim();
+    typeof S == "string" && O && s.push(O);
+    const E = v.trim();
+    typeof v == "string" && E && n.push(E), Array.isArray(b) && a.push(...b), c.status && i.add(c.status);
+    for (const [l, p] of Object.entries(M))
+      if (!(p === void 0 || l.startsWith("__parallel_update_")) && !N(e[l], p)) {
+        if (!Object.hasOwn(o, l)) {
+          o[l] = p;
+          continue;
+        }
+        if (!N(o[l], p))
+          throw new Error(`ParallelWorkflow 检测到状态字段“${l}".`);
+      }
+  }
+  const d = {
+    ...r,
+    ...o
+  }, u = d;
+  return a.length > 0 && (u.agentExecutionContext = {
+    ...e.agentExecutionContext,
+    messages: [...e.agentExecutionContext.messages, ...a]
+  }), s.length && (u.outputMessage = s.join(`
+
+`)), n.length && (u.summary = n.join(`
+
+`)), i.size && (u.status = i.has("failed") ? "failed" : i.has("success") ? "success" : void 0), d;
+}
+function N(e, t) {
+  return e === t ? !0 : e && t ? JSON.stringify(e) === JSON.stringify(t) : !1;
+}
+export {
+  y as ParallelWorkflow
+};

package/dist/agent-utils/workflows/RouterWorkflow.d.ts

@@ -0,0 +1,63 @@
+import type { AgentData, AgentGraphState, BaseAgentLike, GraphEdge } from "../types.js";
+import type { BaseWorkflow } from "./BaseWorkflow.js";
+
+/**
+ * RouterWorkflow runs a router agent, then dispatches to exactly one downstream agent.
+ *
+ * Use in the following scenarios:
+ * - A model (or routing step) should choose the destination,
+ * - Only one branch should run per request
+ *
+ * How it works:
+ * - `routerAgent` always runs first,
+ * - `routerAgent` reads the selected route key from `routerOutputKey`,
+ * - The agent corresponding to the selected route key is dispatched from `agentsMap`.
+ *
+ * @since 5.1
+ */
+export class RouterWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
+  constructor(properties: RouterWorkflowConstructProperties<TState>);
+  /**
+   * Mapping of route keys to destination agents.
+   *
+   * @required
+   */
+  accessor agentsMap: Record<string, BaseAgentLike<TState>>;
+  /**
+   * The agent that decides which route key to select.
+   *
+   * @required
+   */
+  accessor routerAgent: BaseAgentLike<TState>;
+  /**
+   * State key containing the selected route returned by the router agent.
+   *
+   * @required
+   */
+  accessor routerOutputKey: keyof AgentGraphState<TState>;
+  /**
+   * Builds the workflow-specific edges.
+   *
+   * @param agents
+   */
+  protected buildEdges(agents: BaseAgentLike<TState>[]): GraphEdge<AgentGraphState<TState>>[];
+  /** A list of agents that are part of this workflow. */
+  getAgents(): BaseAgentLike<TState>[];
+  /** Returns the id of the first node in the workflow graph. */
+  protected getEntryNode(): string;
+  /**
+   * Returns whether the agent at this position should expose terminal runtime fields.
+   *
+   * @param _agents
+   * @param index
+   */
+  protected isTerminalAgent(_agents: BaseAgentLike<TState>[], index: number): boolean;
+  /**
+   * Validates the workflow configuration and throws if invalid.
+   *
+   * @param agents
+   */
+  protected validateAgents(agents: BaseAgentLike<TState>[]): void;
+}
+
+export type RouterWorkflowConstructProperties<TState extends AgentData> = Pick<RouterWorkflow<TState>, "agentsMap" | "routerAgent" | "routerOutputKey">;

package/dist/agent-utils/workflows/RouterWorkflow.js

@@ -0,0 +1,75 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.1/LICENSE.txt */
+import { property as h, subclass as g } from "@geoscene/core/core/accessorSupport/decorators.js";
+import { B as v, g as l } from "../../chunks/BaseWorkflow.js";
+var w = Object.defineProperty, _ = Object.getOwnPropertyDescriptor, f = (e) => {
+  throw TypeError(e);
+}, c = (e, t, o, s) => {
+  for (var r = s > 1 ? void 0 : s ? _(t, o) : t, n = e.length - 1, d; n >= 0; n--)
+    (d = e[n]) && (r = (s ? d(t, o, r) : d(r)) || r);
+  return s && r && w(t, o, r), r;
+}, y = (e, t, o) => t.has(e) || f("Cannot " + o), A = (e, t, o) => t.has(e) ? f("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, o), p = (e, t, o) => (y(e, t, "access private method"), o), a, i;
+let u = class extends v {
+  //#region Lifecycle
+  constructor(e) {
+    super(e), A(this, a);
+  }
+  //#endregion
+  //#region Public Methods
+  getAgents() {
+    return p(this, a, i).call(this), [this.routerAgent, ...Object.values(this.agentsMap)];
+  }
+  buildEdges(e) {
+    p(this, a, i).call(this);
+    const t = l(this.routerAgent, 0), o = /* @__PURE__ */ new Map();
+    for (const [s, [r]] of Object.entries(this.agentsMap).entries())
+      o.set(r, l(e[s + 1], s + 1));
+    return [
+      {
+        from: t,
+        decide: (s) => {
+          const r = s[this.routerOutputKey];
+          if (typeof r != "string" || !r)
+            throw new Error("RouterWorkflow 的 decideRoute 无法根据状态确定下一个 Agent。");
+          const n = o.get(r);
+          if (!n)
+            throw new Error(
+              `RouterWorkflow 的 decideRoute 返回了未知 Agent：${r}。应为以下值之一：${Object.keys(this.agentsMap).join(", ") || "(none)"}.`
+            );
+          return n;
+        }
+      }
+    ];
+  }
+  //#endregion
+  //#region Protected Methods
+  getEntryNode() {
+    return p(this, a, i).call(this), l(this.routerAgent, 0);
+  }
+  isTerminalAgent(e, t) {
+    return t > 0;
+  }
+  validateAgents(e) {
+    p(this, a, i).call(this), super.validateAgents(e);
+  }
+  //#endregion
+};
+a = /* @__PURE__ */ new WeakSet();
+i = function() {
+  if (!Object.keys(this.agentsMap).length)
+    throw new Error("RouterWorkflow 的 agentsMap 不能为空。");
+};
+c([
+  h()
+], u.prototype, "agentsMap", 2);
+c([
+  h()
+], u.prototype, "routerAgent", 2);
+c([
+  h()
+], u.prototype, "routerOutputKey", 2);
+u = c([
+  g("RouterWorkflow")
+], u);
+export {
+  u as RouterWorkflow
+};