@google/adk 1.6.0 → 2.0.0

package/dist/web/workflow/retry_config.js

@@ -0,0 +1,43 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function normalizeRetryExceptions(exceptions) {
+  if (exceptions === void 0 || exceptions === null) {
+    return void 0;
+  }
+  return exceptions.map((item) => {
+    if (typeof item === "string") {
+      return item;
+    }
+    if (typeof item === "function" && item.name) {
+      return item.name;
+    }
+    throw new Error(
+      "exceptions must contain error class names (string) or error classes, got: ".concat(String(
+        item
+      ))
+    );
+  });
+}
+__name(normalizeRetryExceptions, "normalizeRetryExceptions");
+function prepareRetryConfig(config) {
+  return {
+    maxAttempts: config.maxAttempts,
+    initialDelay: config.initialDelay,
+    maxDelay: config.maxDelay,
+    backoffFactor: config.backoffFactor,
+    jitter: config.jitter,
+    exceptions: normalizeRetryExceptions(config.exceptions)
+  };
+}
+__name(prepareRetryConfig, "prepareRetryConfig");
+export {
+  normalizeRetryExceptions,
+  prepareRetryConfig
+};

package/dist/web/workflow/run_llm_agent_as_node.js

@@ -0,0 +1,266 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  createEvent,
+  getFunctionCalls,
+  getFunctionResponses
+} from "../events/event.js";
+import {
+  FINISH_TASK_SUCCESS_RESULT,
+  FINISH_TASK_TOOL_NAME
+} from "../tools/finish_task_tool.js";
+import { logger } from "../utils/logger.js";
+import { isContent } from "./base_node.js";
+function runLlmAgentAsNode(agent, ctx, nodeInput) {
+  return __asyncGenerator(this, null, function* () {
+    const isTaskMode = agent.mode === "task";
+    if (!isTaskMode && !agent.includeContentsExplicit) {
+      agent.includeContents = "none";
+    }
+    if (!isTaskMode) {
+      yield new __await(appendNodeInputAsUserTurn(ctx, nodeInput));
+    }
+    const agentIc = withWorkflowInstructionScope(ctx.getInvocationContext(), {
+      input: nodeInput,
+      outputsByNode: collectPredecessorOutputs(ctx)
+    });
+    if (isTaskMode) {
+      yield* __yieldStar(runTaskMode(ctx, agentIc, agent));
+      return;
+    }
+    try {
+      for (var iter = __forAwait(agent.runAsync(agentIc)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+        const event = temp.value;
+        maybeSetOutput(agent, event);
+        yield event;
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+  });
+}
+__name(runLlmAgentAsNode, "runLlmAgentAsNode");
+async function appendNodeInputAsUserTurn(ctx, nodeInput) {
+  if (nodeInput === void 0 || nodeInput === null) {
+    return;
+  }
+  const userEvent = createEvent({
+    author: "user",
+    invocationId: ctx.invocationId,
+    branch: ctx.branch,
+    content: toUserContent(nodeInput)
+  });
+  if (ctx.isolationScope) {
+    userEvent.isolationScope = ctx.isolationScope;
+  }
+  const sessionService = ctx.invocationContext.sessionService;
+  if (sessionService) {
+    await sessionService.appendEvent({ session: ctx.session, event: userEvent });
+  } else {
+    ctx.session.events.push(userEvent);
+  }
+}
+__name(appendNodeInputAsUserTurn, "appendNodeInputAsUserTurn");
+function runTaskMode(ctx, agentIc, agent) {
+  return __asyncGenerator(this, null, function* () {
+    var _a, _b;
+    const finishTool = agent.finishTaskTool;
+    let pendingArgs;
+    try {
+      for (var iter = __forAwait(agent.runAsync(agentIc)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+        const event = temp.value;
+        const finishCall = getFunctionCalls(event).find(
+          (fc) => fc.name === FINISH_TASK_TOOL_NAME
+        );
+        if (finishCall) {
+          pendingArgs = __spreadValues({}, (_a = finishCall.args) != null ? _a : {});
+          yield event;
+          continue;
+        }
+        if (pendingArgs !== void 0 && isFinishTaskSuccessResponse(event)) {
+          const output = finishTool.extractOutput(pendingArgs);
+          event.output = output;
+          event.nodeInfo = __spreadProps(__spreadValues({}, (_b = event.nodeInfo) != null ? _b : {}), { messageAsOutput: true });
+          if (agent.outputKey && output !== void 0) {
+            ctx.state.set(agent.outputKey, output);
+            event.actions.stateDelta[agent.outputKey] = output;
+          }
+          yield event;
+          return;
+        }
+        yield event;
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+  });
+}
+__name(runTaskMode, "runTaskMode");
+function maybeSetOutput(agent, event) {
+  var _a;
+  if (event.partial) {
+    return;
+  }
+  if (hasFunctionCalls(event)) {
+    return;
+  }
+  const content = event.content;
+  if (!content || content.role !== "model" || !content.parts) {
+    return;
+  }
+  const text = content.parts.filter((p) => p.text && !p.thought).map((p) => p.text).join("");
+  let output = text;
+  if (agent.outputSchema && text.trim()) {
+    try {
+      output = JSON.parse(text);
+    } catch (e) {
+      output = text;
+    }
+  }
+  if (output === "") {
+    logger.debug(
+      "Agent '".concat(agent.name, "' returned an empty response, so this node's ") + "output is the empty string and that is what the next node receives."
+    );
+  }
+  event.output = output;
+  event.nodeInfo = __spreadProps(__spreadValues({}, (_a = event.nodeInfo) != null ? _a : {}), { messageAsOutput: true });
+}
+__name(maybeSetOutput, "maybeSetOutput");
+function withWorkflowInstructionScope(ic, scope) {
+  return ic.clone({ workflowInstructionScope: scope });
+}
+__name(withWorkflowInstructionScope, "withWorkflowInstructionScope");
+function collectPredecessorOutputs(ctx) {
+  var _a;
+  const outputs = {};
+  for (const event of ctx.session.events) {
+    if (event.invocationId !== ctx.invocationId || event.output === void 0) {
+      continue;
+    }
+    const path = (_a = event.nodeInfo) == null ? void 0 : _a.path;
+    if (!path) {
+      continue;
+    }
+    const leaf = path.slice(path.lastIndexOf(".") + 1);
+    const name = leaf.includes("@") ? leaf.slice(0, leaf.indexOf("@")) : leaf;
+    outputs[name] = event.output;
+  }
+  return outputs;
+}
+__name(collectPredecessorOutputs, "collectPredecessorOutputs");
+function hasFunctionCalls(event) {
+  var _a, _b;
+  return ((_b = (_a = event.content) == null ? void 0 : _a.parts) != null ? _b : []).some((p) => p.functionCall);
+}
+__name(hasFunctionCalls, "hasFunctionCalls");
+function isFinishTaskSuccessResponse(event) {
+  return getFunctionResponses(event).some((fr) => {
+    var _a;
+    if (fr.name !== FINISH_TASK_TOOL_NAME) {
+      return false;
+    }
+    const response = (_a = fr.response) != null ? _a : {};
+    return response.result === FINISH_TASK_SUCCESS_RESULT;
+  });
+}
+__name(isFinishTaskSuccessResponse, "isFinishTaskSuccessResponse");
+function toUserContent(input) {
+  if (isContent(input)) {
+    return __spreadProps(__spreadValues({}, input), { role: "user" });
+  }
+  if (typeof input === "string") {
+    return { role: "user", parts: [{ text: input }] };
+  }
+  return { role: "user", parts: [{ text: JSON.stringify(input) }] };
+}
+__name(toUserContent, "toUserContent");
+export {
+  runLlmAgentAsNode
+};

package/dist/web/workflow/run_node_as_invocation.js

@@ -0,0 +1,170 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isBaseAgent } from "../agents/base_agent.js";
+import { createEvent } from "../events/event.js";
+import { AsyncQueue } from "../utils/async_queue.js";
+import { toContent } from "./base_node.js";
+import { NodeContext } from "./node_context.js";
+import {
+  eventsForCurrentRun,
+  reconstructNodeStates
+} from "./utils/rehydration_utils.js";
+import { buildNode, isNodeLike } from "./utils/workflow_graph_utils.js";
+import { isWorkflow, Workflow } from "./workflow.js";
+function runNodeAsInvocation(_0, _1) {
+  return __asyncGenerator(this, arguments, function* (node, ic, options = {}) {
+    var _a;
+    const author = (_a = options.author) != null ? _a : node.name;
+    const channel = new AsyncQueue();
+    const root = new NodeContext({
+      invocationContext: ic,
+      channel,
+      nodePath: "",
+      runId: author,
+      // Interactive resume: if the node is paused on an interrupt and the user
+      // replies with plain text (not a structured function response), feed that
+      // text to the pending interrupt(s). Structured function responses are still
+      // resolved by the workflow's own rehydration.
+      resumeInputs: resumeInputsFromPlainText(ic)
+    });
+    const input = extractNodeInput(ic.userContent);
+    let interrupted = false;
+    const settle = (async () => {
+      try {
+        const nodeCtx = await root.runNode(node, input, { useAsOutput: true });
+        interrupted = nodeCtx.interruptIds.length > 0;
+        channel.close();
+      } catch (err) {
+        channel.fail(err);
+      }
+    })();
+    let lastOutput;
+    let sawOutput = false;
+    try {
+      try {
+        for (var iter = __forAwait(channel), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const event = temp.value;
+          if (event.output !== void 0) {
+            lastOutput = event.output;
+            sawOutput = true;
+          }
+          yield event;
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      yield new __await(settle);
+    } finally {
+      channel.close();
+      yield new __await(settle);
+    }
+    const alreadyLast = sawOutput && Object.is(lastOutput, root.output);
+    if (!interrupted && root.output !== void 0 && !alreadyLast) {
+      yield createEvent({
+        author,
+        invocationId: ic.invocationId,
+        branch: ic.branch,
+        content: toContent(root.output),
+        output: root.output
+      });
+    }
+  });
+}
+__name(runNodeAsInvocation, "runNodeAsInvocation");
+function resumeInputsFromPlainText(ic) {
+  var _a, _b, _c, _d;
+  const parts = (_b = (_a = ic.userContent) == null ? void 0 : _a.parts) != null ? _b : [];
+  const isPlainText = parts.length > 0 && parts.every((p) => typeof p.text === "string");
+  if (!isPlainText) {
+    return {};
+  }
+  const text = parts.map((p) => p.text).join("");
+  const pending = /* @__PURE__ */ new Set();
+  const events = eventsForCurrentRun((_d = (_c = ic.session) == null ? void 0 : _c.events) != null ? _d : [], ic.invocationId);
+  for (const nodeState of reconstructNodeStates(events).values()) {
+    for (const id2 of nodeState.interruptIds) {
+      if (!nodeState.resolvedResponses.has(id2)) {
+        pending.add(id2);
+      }
+    }
+  }
+  if (pending.size !== 1) {
+    return {};
+  }
+  const [id] = pending;
+  return { [id]: text };
+}
+__name(resumeInputsFromPlainText, "resumeInputsFromPlainText");
+function extractNodeInput(content) {
+  var _a;
+  if (!content) {
+    return void 0;
+  }
+  const parts = (_a = content.parts) != null ? _a : [];
+  const textParts = parts.filter((p) => typeof p.text === "string");
+  if (textParts.length > 0) {
+    return textParts.map((p) => p.text).join("");
+  }
+  return content;
+}
+__name(extractNodeInput, "extractNodeInput");
+function isRunnableRoot(value) {
+  return isBaseAgent(value) || isWorkflow(value);
+}
+__name(isRunnableRoot, "isRunnableRoot");
+function asRunnableRoot(root) {
+  var _a, _b;
+  if (isRunnableRoot(root)) {
+    return root;
+  }
+  const value = root;
+  if (!isNodeLike(value) || value === "START") {
+    const described = value === "START" ? "the 'START' sentinel" : (_b = (_a = value == null ? void 0 : value.constructor) == null ? void 0 : _a.name) != null ? _b : typeof value;
+    throw new TypeError(
+      "Cannot use ".concat(described, " as a root: expected a BaseAgent, a Workflow, ") + "or a node-like value (a node, a tool, or a function)."
+    );
+  }
+  const built = buildNode(value);
+  return new Workflow({
+    name: built.name,
+    description: built.description,
+    edges: [["START", built]]
+  });
+}
+__name(asRunnableRoot, "asRunnableRoot");
+export {
+  asRunnableRoot,
+  isRunnableRoot,
+  runNodeAsInvocation
+};

package/dist/web/workflow/schedule_dynamic_node.js

@@ -0,0 +1,26 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const _DynamicNodeState = class _DynamicNodeState {
+  constructor() {
+    /** Dynamic node runs keyed by unique node path (e.g. `wf/node_a@1`). */
+    this.runs = /* @__PURE__ */ new Map();
+    /** Union of unresolved interrupt ids across dynamic child nodes. */
+    this.interruptIds = /* @__PURE__ */ new Set();
+  }
+  /** All in-flight dynamic node tasks. */
+  getDynamicTasks() {
+    return [...this.runs.values()].map((run) => run.task).filter((task) => task !== void 0);
+  }
+};
+__name(_DynamicNodeState, "DynamicNodeState");
+let DynamicNodeState = _DynamicNodeState;
+export {
+  DynamicNodeState
+};

package/dist/web/workflow/trigger.js

@@ -0,0 +1,7 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/web/workflow/utils/graph_parser.js

@@ -0,0 +1,188 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  Edge,
+  isEdge
+} from "../graph.js";
+import { buildNode, isNodeLike, isPlainObject } from "./workflow_graph_utils.js";
+function normalizeRouteKey(routeKey) {
+  if (/^-?\d+$/.test(routeKey)) {
+    return Number(routeKey);
+  }
+  if (routeKey === "true" || routeKey === "false") {
+    return routeKey === "true";
+  }
+  return routeKey;
+}
+__name(normalizeRouteKey, "normalizeRouteKey");
+function expandRoutingMap(fromElement, routingMap) {
+  const keys = Object.keys(routingMap);
+  if (keys.length === 0) {
+    throw new Error(
+      "Routing map must not be empty. Provide at least one route -> node mapping."
+    );
+  }
+  const expanded = [];
+  for (const routeKey of keys) {
+    const normalizedKey = normalizeRouteKey(routeKey);
+    const target = routingMap[routeKey];
+    if (Array.isArray(target)) {
+      for (const node of target) {
+        if (!isNodeLike(node)) {
+          throw new Error(
+            "Invalid node in fan-out tuple for route ".concat(String(routeKey), ".")
+          );
+        }
+      }
+    } else if (!isNodeLike(target)) {
+      throw new Error(
+        "Invalid routing map value for route ".concat(String(routeKey), ".")
+      );
+    }
+    expanded.push([
+      fromElement,
+      target,
+      normalizedKey
+    ]);
+  }
+  return expanded;
+}
+__name(expandRoutingMap, "expandRoutingMap");
+function nodesFromRoutingMap(routingMap) {
+  const nodes = [];
+  for (const target of Object.values(routingMap)) {
+    if (Array.isArray(target)) {
+      nodes.push(...target);
+    } else {
+      nodes.push(target);
+    }
+  }
+  return nodes;
+}
+__name(nodesFromRoutingMap, "nodesFromRoutingMap");
+function flattenElement(element) {
+  if (isPlainObject(element)) {
+    return nodesFromRoutingMap(element);
+  }
+  if (Array.isArray(element)) {
+    return [...element];
+  }
+  return [element];
+}
+__name(flattenElement, "flattenElement");
+function getOrBuildNode(nodeLike, nodeMap) {
+  if (nodeLike === "START") {
+    return buildNode("START");
+  }
+  if (typeof nodeLike === "object" || typeof nodeLike === "function") {
+    const cached = nodeMap.get(nodeLike);
+    if (cached) {
+      return cached;
+    }
+    const built = buildNode(nodeLike);
+    nodeMap.set(nodeLike, built);
+    return built;
+  }
+  return buildNode(nodeLike);
+}
+__name(getOrBuildNode, "getOrBuildNode");
+function processExplicitEdge({
+  edge,
+  nodeMap,
+  out
+}) {
+  out.push(
+    new Edge(
+      getOrBuildNode(edge.fromNode, nodeMap),
+      getOrBuildNode(edge.toNode, nodeMap),
+      edge.route
+    )
+  );
+}
+__name(processExplicitEdge, "processExplicitEdge");
+function processRoutingMapEdge({
+  fromEl,
+  toEl,
+  nodeMap,
+  out
+}) {
+  if (isPlainObject(fromEl)) {
+    throw new Error(
+      "Consecutive routing maps are not allowed in a chain. Split them into separate edge items."
+    );
+  }
+  for (const [expFrom, expTo, route] of expandRoutingMap(fromEl, toEl)) {
+    for (const fromNode of flattenElement(expFrom)) {
+      for (const toNode of flattenElement(expTo)) {
+        out.push(
+          new Edge(
+            getOrBuildNode(fromNode, nodeMap),
+            getOrBuildNode(toNode, nodeMap),
+            route
+          )
+        );
+      }
+    }
+  }
+}
+__name(processRoutingMapEdge, "processRoutingMapEdge");
+function processUnconditionalEdge({
+  fromEl,
+  toEl,
+  nodeMap,
+  out
+}) {
+  for (const fromNode of flattenElement(fromEl)) {
+    for (const toNode of flattenElement(toEl)) {
+      out.push(
+        new Edge(
+          getOrBuildNode(fromNode, nodeMap),
+          getOrBuildNode(toNode, nodeMap),
+          null
+        )
+      );
+    }
+  }
+}
+__name(processUnconditionalEdge, "processUnconditionalEdge");
+function processChain({
+  chain,
+  nodeMap,
+  out
+}) {
+  for (let i = 0; i < chain.length - 1; i++) {
+    const fromEl = chain[i];
+    const toEl = chain[i + 1];
+    if (isPlainObject(toEl)) {
+      processRoutingMapEdge({ fromEl, toEl, nodeMap, out });
+    } else {
+      processUnconditionalEdge({ fromEl, toEl, nodeMap, out });
+    }
+  }
+}
+__name(processChain, "processChain");
+function parseEdgeItems(edgeItems) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const item of edgeItems) {
+    if (isEdge(item)) {
+      processExplicitEdge({ edge: item, nodeMap, out });
+    } else if (Array.isArray(item)) {
+      processChain({ chain: item, nodeMap, out });
+    } else {
+      throw new Error("Invalid edge item type: ".concat(typeof item));
+    }
+  }
+  return out;
+}
+__name(parseEdgeItems, "parseEdgeItems");
+export {
+  parseEdgeItems
+};