@google/adk 1.6.0 → 2.1.0

package/dist/esm/workflow/run_node_as_invocation.js

@@ -0,0 +1,139 @@
+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 { 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";
+async function* runNodeAsInvocation(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 {
+    for await (const event of channel) {
+      if (event.output !== void 0) {
+        lastOutput = event.output;
+        sawOutput = true;
+      }
+      yield event;
+    }
+    await settle;
+  } finally {
+    channel.close();
+    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 ${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/esm/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/esm/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 ${String(routeKey)}.`
+          );
+        }
+      }
+    } else if (!isNodeLike(target)) {
+      throw new Error(
+        `Invalid routing map value for route ${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: ${typeof item}`);
+    }
+  }
+  return out;
+}
+__name(parseEdgeItems, "parseEdgeItems");
+export {
+  parseEdgeItems
+};

package/dist/esm/workflow/utils/graph_validation.js

@@ -0,0 +1,189 @@
+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 { START } from "../base_node.js";
+import { DEFAULT_ROUTE } from "../graph.js";
+function validateDuplicateNodeNames(nodes) {
+  var _a;
+  const counts = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    counts.set(node.name, ((_a = counts.get(node.name)) != null ? _a : 0) + 1);
+  }
+  const duplicates = [...counts.entries()].filter(([, c]) => c > 1).map(([name]) => name).sort();
+  if (duplicates.length > 0) {
+    throw new Error(
+      `Graph validation failed. Duplicate node names found: ${JSON.stringify(
+        duplicates
+      )}. Pass the exact same object instance to reuse a node, or give distinct nodes unique names.`
+    );
+  }
+  return new Set(counts.keys());
+}
+__name(validateDuplicateNodeNames, "validateDuplicateNodeNames");
+function validateStartNode(nodeNames) {
+  if (!nodeNames.has(START.name)) {
+    throw new Error(
+      `Graph validation failed. START node (name: '${START.name}') not found in graph nodes.`
+    );
+  }
+}
+__name(validateStartNode, "validateStartNode");
+function validateStartEdges(edges) {
+  for (const edge of edges) {
+    if (edge.fromNode.name === START.name && edge.route !== null) {
+      throw new Error(
+        `Graph validation failed. Edges from START must not have routes (edge to ${edge.toNode.name} has route ${String(
+          edge.route
+        )}).`
+      );
+    }
+  }
+}
+__name(validateStartEdges, "validateStartEdges");
+function validateConnectivity(edges, nodeNames) {
+  var _a;
+  const adj = /* @__PURE__ */ new Map();
+  for (const name of nodeNames) {
+    adj.set(name, /* @__PURE__ */ new Set());
+  }
+  const toNodes = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    adj.get(edge.fromNode.name).add(edge.toNode.name);
+    toNodes.add(edge.toNode.name);
+  }
+  const reachable = /* @__PURE__ */ new Set();
+  const stack = [START.name];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (reachable.has(node)) {
+      continue;
+    }
+    reachable.add(node);
+    for (const next of (_a = adj.get(node)) != null ? _a : []) {
+      if (!reachable.has(next)) {
+        stack.push(next);
+      }
+    }
+  }
+  const unreachable = [...nodeNames].filter((n) => !reachable.has(n)).sort();
+  if (unreachable.length > 0) {
+    throw new Error(
+      `Graph validation failed. The following nodes are unreachable from START: ${JSON.stringify(
+        unreachable
+      )}`
+    );
+  }
+  if (toNodes.has(START.name)) {
+    throw new Error(
+      "Graph validation failed. START node must not have incoming edges."
+    );
+  }
+}
+__name(validateConnectivity, "validateConnectivity");
+function validateDuplicateEdges(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    const unconditional = edge.route === null || edge.route === void 0;
+    const routes = unconditional ? [null] : (Array.isArray(edge.route) ? edge.route : [edge.route]).map(String);
+    for (const route of routes) {
+      const key = JSON.stringify([edge.fromNode.name, edge.toNode.name, route]);
+      if (seen.has(key)) {
+        throw new Error(
+          `Graph validation failed. Duplicate edge found: from=${edge.fromNode.name}, to=${edge.toNode.name}${unconditional ? "" : `, route=${JSON.stringify(route)}`}. ${unconditional ? "The same pair is already connected unconditionally" : "That route already points at this node"}, so the target would be triggered twice.`
+        );
+      }
+      seen.add(key);
+    }
+  }
+}
+__name(validateDuplicateEdges, "validateDuplicateEdges");
+function validateDefaultRoutes(edges) {
+  const defaultRouteEdges = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (Array.isArray(edge.route) && edge.route.includes(DEFAULT_ROUTE)) {
+      throw new Error(
+        `Graph validation failed. DEFAULT_ROUTE cannot be combined with other routes in a list (edge from=${edge.fromNode.name}, to=${edge.toNode.name}). Use a separate edge for DEFAULT_ROUTE.`
+      );
+    }
+    if (edge.route === DEFAULT_ROUTE) {
+      const from = edge.fromNode.name;
+      if (defaultRouteEdges.has(from)) {
+        throw new Error(
+          `Graph validation failed. Multiple DEFAULT_ROUTE edges found from node ${from} to ${defaultRouteEdges.get(
+            from
+          )} and ${edge.toNode.name}`
+        );
+      }
+      defaultRouteEdges.set(from, edge.toNode.name);
+    }
+  }
+}
+__name(validateDefaultRoutes, "validateDefaultRoutes");
+function detectUnconditionalCycles(edges, nodeNames) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const name of nodeNames) {
+    adj.set(name, []);
+  }
+  for (const edge of edges) {
+    if (edge.route === null) {
+      adj.get(edge.fromNode.name).push(edge.toNode.name);
+    }
+  }
+  const inStack = /* @__PURE__ */ new Set();
+  const done = /* @__PURE__ */ new Set();
+  const dfs = /* @__PURE__ */ __name((node, path) => {
+    var _a;
+    inStack.add(node);
+    path.push(node);
+    for (const neighbor of (_a = adj.get(node)) != null ? _a : []) {
+      if (inStack.has(neighbor)) {
+        const cycleStart = path.indexOf(neighbor);
+        const cycle = [...path.slice(cycleStart), neighbor];
+        throw new Error(
+          `Graph validation failed. Unconditional cycle detected: ${cycle.join(
+            " -> "
+          )}. An unconditional cycle has no exit and would loop forever; break it with at least one conditional (routed) edge so a node can leave the cycle by not emitting that route. (A routed cycle can still loop if a node keeps emitting the route \u2014 bounding that is the node's responsibility, not this validator's.)`
+        );
+      }
+      if (!done.has(neighbor)) {
+        dfs(neighbor, path);
+      }
+    }
+    path.pop();
+    inStack.delete(node);
+    done.add(node);
+  }, "dfs");
+  for (const name of nodeNames) {
+    if (!done.has(name)) {
+      dfs(name, []);
+    }
+  }
+}
+__name(detectUnconditionalCycles, "detectUnconditionalCycles");
+function computeTerminalNodes(nodes, edges) {
+  const fromNames = new Set(edges.map((e) => e.fromNode.name));
+  return new Set(
+    nodes.filter((n) => n.name !== START.name && !fromNames.has(n.name)).map((n) => n.name)
+  );
+}
+__name(computeTerminalNodes, "computeTerminalNodes");
+function validateGraph(nodes, edges) {
+  const nodeNames = validateDuplicateNodeNames(nodes);
+  validateStartNode(nodeNames);
+  validateStartEdges(edges);
+  validateConnectivity(edges, nodeNames);
+  validateDuplicateEdges(edges);
+  validateDefaultRoutes(edges);
+  detectUnconditionalCycles(edges, nodeNames);
+  return computeTerminalNodes(nodes, edges);
+}
+__name(validateGraph, "validateGraph");
+export {
+  validateGraph
+};