@google/adk 1.5.0 → 2.0.0

package/dist/web/workflow/errors.js

@@ -0,0 +1,140 @@
+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 _NodeInterruptedError = class _NodeInterruptedError extends Error {
+  constructor(message = "Node interrupted (awaiting resume input).") {
+    super(message);
+    this.name = "NodeInterruptedError";
+    Object.setPrototypeOf(this, _NodeInterruptedError.prototype);
+  }
+};
+__name(_NodeInterruptedError, "NodeInterruptedError");
+let NodeInterruptedError = _NodeInterruptedError;
+function isNodeInterruptedError(e) {
+  return e instanceof Error && e.name === "NodeInterruptedError";
+}
+__name(isNodeInterruptedError, "isNodeInterruptedError");
+const _NodeTimeoutError = class _NodeTimeoutError extends Error {
+  /**
+   * @param options.nodeName The name of the node that timed out.
+   * @param options.timeout The timeout, in seconds, that was exceeded.
+   */
+  constructor(options) {
+    super(
+      "Node '".concat(options.nodeName, "' timed out after ").concat(options.timeout, " seconds.")
+    );
+    this.name = "NodeTimeoutError";
+    this.nodeName = options.nodeName;
+    this.timeout = options.timeout;
+    Object.setPrototypeOf(this, _NodeTimeoutError.prototype);
+  }
+};
+__name(_NodeTimeoutError, "NodeTimeoutError");
+let NodeTimeoutError = _NodeTimeoutError;
+function isNodeTimeoutError(e) {
+  return e instanceof Error && e.name === "NodeTimeoutError";
+}
+__name(isNodeTimeoutError, "isNodeTimeoutError");
+const _DynamicNodeFailError = class _DynamicNodeFailError extends Error {
+  /**
+   * @param options.message Human-readable failure message.
+   * @param options.error The underlying error thrown by the dynamic node.
+   * @param options.errorNodePath The node path where the failure occurred.
+   */
+  constructor(options) {
+    super(options.message);
+    this.name = "DynamicNodeFailError";
+    this.error = options.error;
+    this.errorNodePath = options.errorNodePath;
+    Object.setPrototypeOf(this, _DynamicNodeFailError.prototype);
+  }
+};
+__name(_DynamicNodeFailError, "DynamicNodeFailError");
+let DynamicNodeFailError = _DynamicNodeFailError;
+function isDynamicNodeFailError(e) {
+  return e instanceof Error && e.name === "DynamicNodeFailError";
+}
+__name(isDynamicNodeFailError, "isDynamicNodeFailError");
+const _NodeReportedError = class _NodeReportedError extends Error {
+  /**
+   * @param options.nodeName The node that reported the error.
+   * @param options.errorCode The code carried on the reported event.
+   * @param options.errorMessage The message carried on the reported event.
+   */
+  constructor(options) {
+    var _a, _b;
+    const code = (_a = options.errorCode) != null ? _a : "UNKNOWN_ERROR";
+    const detail = (_b = options.errorMessage) != null ? _b : code;
+    super(
+      "Node '".concat(options.nodeName, "' failed: ").concat(code === "UNKNOWN_ERROR" ? detail : "".concat(code, ": ").concat(detail))
+    );
+    this.name = "NodeReportedError";
+    this.code = code;
+    this.nodeName = options.nodeName;
+    Object.setPrototypeOf(this, _NodeReportedError.prototype);
+  }
+};
+__name(_NodeReportedError, "NodeReportedError");
+let NodeReportedError = _NodeReportedError;
+function isNodeReportedError(e) {
+  return e instanceof Error && e.name === "NodeReportedError";
+}
+__name(isNodeReportedError, "isNodeReportedError");
+const _InvocationAbortedError = class _InvocationAbortedError extends Error {
+  constructor(message = "Invocation aborted.") {
+    super(message);
+    this.name = "InvocationAbortedError";
+    Object.setPrototypeOf(this, _InvocationAbortedError.prototype);
+  }
+};
+__name(_InvocationAbortedError, "InvocationAbortedError");
+let InvocationAbortedError = _InvocationAbortedError;
+function isInvocationAbortedError(e) {
+  return e instanceof Error && e.name === "InvocationAbortedError";
+}
+__name(isInvocationAbortedError, "isInvocationAbortedError");
+const _NodeSchemaValidationError = class _NodeSchemaValidationError extends Error {
+  /**
+   * @param options.nodeName The name of the node that failed validation.
+   * @param options.direction Whether the input or the output failed.
+   * @param options.cause The underlying validation error.
+   */
+  constructor(options) {
+    const schemaName = options.direction === "input" ? "inputSchema" : "outputSchema";
+    const detail = options.cause instanceof Error ? options.cause.message : String(options.cause);
+    super(
+      "Node '".concat(options.nodeName, "' ").concat(options.direction, " does not match its ") + "".concat(schemaName, ": ").concat(detail),
+      { cause: options.cause }
+    );
+    this.name = "NodeSchemaValidationError";
+    this.nodeName = options.nodeName;
+    this.direction = options.direction;
+    Object.setPrototypeOf(this, _NodeSchemaValidationError.prototype);
+  }
+};
+__name(_NodeSchemaValidationError, "NodeSchemaValidationError");
+let NodeSchemaValidationError = _NodeSchemaValidationError;
+function isNodeSchemaValidationError(e) {
+  return e instanceof Error && e.name === "NodeSchemaValidationError";
+}
+__name(isNodeSchemaValidationError, "isNodeSchemaValidationError");
+export {
+  DynamicNodeFailError,
+  InvocationAbortedError,
+  NodeInterruptedError,
+  NodeReportedError,
+  NodeSchemaValidationError,
+  NodeTimeoutError,
+  isDynamicNodeFailError,
+  isInvocationAbortedError,
+  isNodeInterruptedError,
+  isNodeReportedError,
+  isNodeSchemaValidationError,
+  isNodeTimeoutError
+};

package/dist/web/workflow/graph.js

@@ -0,0 +1,127 @@
+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
+ */
+var _a;
+import { logger } from "../utils/logger.js";
+import { parseEdgeItems } from "./utils/graph_parser.js";
+import { validateGraph } from "./utils/graph_validation.js";
+const EDGE_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.edge");
+const DEFAULT_ROUTE = "__DEFAULT__";
+_a = EDGE_SIGNATURE_SYMBOL;
+const _Edge = class _Edge {
+  constructor(fromNode, toNode, route = null) {
+    this.fromNode = fromNode;
+    this.toNode = toNode;
+    this.route = route;
+    /** Brand identifying this object as an {@link Edge} (see `isEdge`). */
+    this[_a] = true;
+  }
+};
+__name(_Edge, "Edge");
+let Edge = _Edge;
+function isEdge(value) {
+  return typeof value === "object" && value !== null && EDGE_SIGNATURE_SYMBOL in value && value[EDGE_SIGNATURE_SYMBOL] === true;
+}
+__name(isEdge, "isEdge");
+const _Graph = class _Graph {
+  constructor(edges) {
+    this._terminalNodeNames = /* @__PURE__ */ new Set();
+    this.edges = edges;
+    const seen = /* @__PURE__ */ new Set();
+    const nodes = [];
+    for (const edge of edges) {
+      for (const node of [edge.fromNode, edge.toNode]) {
+        if (!seen.has(node)) {
+          seen.add(node);
+          nodes.push(node);
+        }
+      }
+    }
+    this.nodes = nodes;
+  }
+  /** Terminal node names (no outgoing edges); populated by {@link validate}. */
+  get terminalNodeNames() {
+    return this._terminalNodeNames;
+  }
+  /**
+   * Determines the next nodes to transition to PENDING based on the route(s)
+   * emitted by a completed node. Ported from Python `get_next_pending_nodes`.
+   *
+   * Logs at debug when the node emitted a route, has conditional outgoing
+   * edges, and none of them (nor a `DEFAULT_ROUTE` edge) matched — the branch
+   * stops there, which is easy to mistake for a bug. Behaviour is unchanged.
+   */
+  getNextPendingNodes(nodeName, routesToMatch) {
+    const nextPending = [];
+    let matchedSpecificRoute = false;
+    let defaultRouteNode;
+    const availableRoutes = [];
+    for (const edge of this.edges) {
+      if (edge.fromNode.name !== nodeName) {
+        continue;
+      }
+      if (edge.route === null || edge.route === void 0) {
+        nextPending.push(edge.toNode.name);
+        continue;
+      }
+      if (edge.route === DEFAULT_ROUTE) {
+        defaultRouteNode = edge.toNode.name;
+        continue;
+      }
+      const edgeRoutes = new Set(
+        (Array.isArray(edge.route) ? edge.route : [edge.route]).map(String)
+      );
+      availableRoutes.push(...edgeRoutes);
+      let edgeMatched = false;
+      if (Array.isArray(routesToMatch)) {
+        edgeMatched = routesToMatch.some((r) => edgeRoutes.has(String(r)));
+      } else if (routesToMatch !== null && routesToMatch !== void 0) {
+        edgeMatched = edgeRoutes.has(String(routesToMatch));
+      }
+      if (edgeMatched) {
+        nextPending.push(edge.toNode.name);
+        matchedSpecificRoute = true;
+      }
+    }
+    if (!matchedSpecificRoute && defaultRouteNode) {
+      nextPending.push(defaultRouteNode);
+    }
+    if (nextPending.length === 0 && availableRoutes.length > 0) {
+      const emitted = routesToMatch === null || routesToMatch === void 0 ? [] : Array.isArray(routesToMatch) ? routesToMatch : [routesToMatch];
+      const isConditionalContinue = availableRoutes.includes("true") && emitted.length > 0 && emitted.every((r) => String(r) === "false");
+      if (emitted.length > 0 && !isConditionalContinue) {
+        const shown = emitted.map((r) => JSON.stringify(r)).join(", ");
+        const known = [...new Set(availableRoutes)].map((r) => JSON.stringify(r)).join(", ");
+        logger.debug(
+          "Node '".concat(nodeName, "' emitted route ").concat(shown, ", which matches no ") + "outgoing edge, so this branch stops here. Edges from this node " + "are keyed to: ".concat(known, ".")
+        );
+      }
+    }
+    return nextPending;
+  }
+  /** Validates the graph and computes terminal node names. */
+  validate() {
+    this._terminalNodeNames = validateGraph(this.nodes, this.edges);
+  }
+};
+__name(_Graph, "Graph");
+let Graph = _Graph;
+function createGraphFromEdgeItems(edgeItems) {
+  const graph = new Graph(parseEdgeItems(edgeItems));
+  graph.validate();
+  return graph;
+}
+__name(createGraphFromEdgeItems, "createGraphFromEdgeItems");
+export {
+  DEFAULT_ROUTE,
+  Edge,
+  Graph,
+  createGraphFromEdgeItems,
+  isEdge
+};

package/dist/web/workflow/index.js

@@ -0,0 +1,80 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  asRunnableRoot,
+  isRunnableRoot,
+  runNodeAsInvocation
+} from "./run_node_as_invocation.js";
+import { Workflow, isWorkflow } from "./workflow.js";
+import { BaseNode, START } from "./base_node.js";
+import { WorkflowNode, node } from "./node.js";
+import { FunctionNode } from "./nodes/function_node.js";
+import { JoinNode } from "./nodes/join_node.js";
+import { NodeTool } from "./nodes/node_tool.js";
+import { ParallelWorker } from "./nodes/parallel_worker.js";
+import { ToolNode } from "./nodes/tool_node.js";
+import { DEFAULT_ROUTE, Edge, Graph } from "./graph.js";
+import { BranchPath, commonPrefixOf, createSubBranch } from "./branch_path.js";
+import { NodeContext } from "./node_context.js";
+import { createNodeState, isNodeState } from "./node_state.js";
+import { NodeStatus } from "./node_status.js";
+import { RequestInput, isRequestInput } from "./request_input.js";
+import {
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
+  REQUEST_INPUT_FUNCTION_CALL_NAME
+} from "./utils/hitl_utils.js";
+import { normalizeRetryExceptions, prepareRetryConfig } from "./retry_config.js";
+import {
+  NodeReportedError,
+  NodeSchemaValidationError,
+  NodeTimeoutError,
+  isNodeReportedError,
+  isNodeSchemaValidationError,
+  isNodeTimeoutError
+} from "./errors.js";
+import { createNodeErrorEvent, isNodeErrorEvent } from "./node_error_event.js";
+export {
+  BaseNode,
+  BranchPath,
+  DEFAULT_ROUTE,
+  Edge,
+  FunctionNode,
+  Graph,
+  JoinNode,
+  NodeContext,
+  NodeReportedError,
+  NodeSchemaValidationError,
+  NodeStatus,
+  NodeTimeoutError,
+  NodeTool,
+  ParallelWorker,
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
+  REQUEST_INPUT_FUNCTION_CALL_NAME,
+  RequestInput,
+  START,
+  ToolNode,
+  Workflow,
+  WorkflowNode,
+  asRunnableRoot,
+  commonPrefixOf,
+  createNodeErrorEvent,
+  createNodeState,
+  createSubBranch,
+  isNodeErrorEvent,
+  isNodeReportedError,
+  isNodeSchemaValidationError,
+  isNodeState,
+  isNodeTimeoutError,
+  isRequestInput,
+  isRunnableRoot,
+  isWorkflow,
+  node,
+  normalizeRetryExceptions,
+  prepareRetryConfig,
+  runNodeAsInvocation
+};

package/dist/web/workflow/node.js

@@ -0,0 +1,87 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+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;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { experimental } from "../utils/experimental.js";
+import { BaseNode } from "./base_node.js";
+import { buildNode } from "./utils/workflow_graph_utils.js";
+function node(nodeLike, options = {}) {
+  return buildNode(nodeLike, options);
+}
+__name(node, "node");
+let WorkflowNode = class extends BaseNode {
+  runImpl(ctx, input) {
+    return __asyncGenerator(this, null, function* () {
+      yield* __yieldStar(this.runNodeImpl(ctx, input));
+    });
+  }
+};
+__name(WorkflowNode, "WorkflowNode");
+WorkflowNode = __decorateClass([
+  experimental
+], WorkflowNode);
+export {
+  WorkflowNode,
+  node
+};

package/dist/web/workflow/node_builders.js

@@ -0,0 +1,40 @@
+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 { isBaseTool } from "../tools/base_tool.js";
+import { FunctionNode } from "./nodes/function_node.js";
+import { ParallelWorker } from "./nodes/parallel_worker.js";
+import { ToolNode } from "./nodes/tool_node.js";
+const FUNCTION_BUILDER = {
+  match: /* @__PURE__ */ __name((value) => typeof value === "function", "match"),
+  build: /* @__PURE__ */ __name((value, options) => {
+    var _a;
+    const handler = value;
+    const name = (_a = options.name) != null ? _a : handler.name;
+    if (!name) {
+      throw new Error(
+        "node(): the wrapped function has no name; pass {name} explicitly."
+      );
+    }
+    return new FunctionNode(name, handler, options);
+  }, "build")
+};
+const TOOL_BUILDER = {
+  match: /* @__PURE__ */ __name((value) => isBaseTool(value), "match"),
+  build: /* @__PURE__ */ __name((value, options) => new ToolNode(value, options), "build")
+};
+const NODE_BUILDERS = [
+  FUNCTION_BUILDER,
+  TOOL_BUILDER
+];
+const PARALLEL_WORKER_FACTORY = /* @__PURE__ */ __name((inner, options) => new ParallelWorker(inner, options), "PARALLEL_WORKER_FACTORY");
+export {
+  NODE_BUILDERS,
+  PARALLEL_WORKER_FACTORY
+};