@google/adk 1.6.0 → 2.1.0

package/dist/cjs/workflow/errors.js

@@ -0,0 +1,178 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  DynamicNodeFailError: () => DynamicNodeFailError,
+  InvocationAbortedError: () => InvocationAbortedError,
+  NodeInterruptedError: () => NodeInterruptedError,
+  NodeReportedError: () => NodeReportedError,
+  NodeSchemaValidationError: () => NodeSchemaValidationError,
+  NodeTimeoutError: () => NodeTimeoutError,
+  isDynamicNodeFailError: () => isDynamicNodeFailError,
+  isInvocationAbortedError: () => isInvocationAbortedError,
+  isNodeInterruptedError: () => isNodeInterruptedError,
+  isNodeReportedError: () => isNodeReportedError,
+  isNodeSchemaValidationError: () => isNodeSchemaValidationError,
+  isNodeTimeoutError: () => isNodeTimeoutError
+});
+module.exports = __toCommonJS(errors_exports);
+/**
+ * @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 '${options.nodeName}' timed out after ${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 '${options.nodeName}' failed: ${code === "UNKNOWN_ERROR" ? detail : `${code}: ${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 '${options.nodeName}' ${options.direction} does not match its ${schemaName}: ${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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DynamicNodeFailError,
+  InvocationAbortedError,
+  NodeInterruptedError,
+  NodeReportedError,
+  NodeSchemaValidationError,
+  NodeTimeoutError,
+  isDynamicNodeFailError,
+  isInvocationAbortedError,
+  isNodeInterruptedError,
+  isNodeReportedError,
+  isNodeSchemaValidationError,
+  isNodeTimeoutError
+});

package/dist/cjs/workflow/graph.js

@@ -0,0 +1,158 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graph_exports = {};
+__export(graph_exports, {
+  DEFAULT_ROUTE: () => DEFAULT_ROUTE,
+  Edge: () => Edge,
+  Graph: () => Graph,
+  createGraphFromEdgeItems: () => createGraphFromEdgeItems,
+  isEdge: () => isEdge
+});
+module.exports = __toCommonJS(graph_exports);
+var import_logger = require("../utils/logger.js");
+var import_graph_parser = require("./utils/graph_parser.js");
+var import_graph_validation = require("./utils/graph_validation.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+const EDGE_SIGNATURE_SYMBOL = /* @__PURE__ */ 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(", ");
+        import_logger.logger.debug(
+          `Node '${nodeName}' emitted route ${shown}, which matches no outgoing edge, so this branch stops here. Edges from this node are keyed to: ${known}.`
+        );
+      }
+    }
+    return nextPending;
+  }
+  /** Validates the graph and computes terminal node names. */
+  validate() {
+    this._terminalNodeNames = (0, import_graph_validation.validateGraph)(this.nodes, this.edges);
+  }
+};
+__name(_Graph, "Graph");
+let Graph = _Graph;
+function createGraphFromEdgeItems(edgeItems) {
+  const graph = new Graph((0, import_graph_parser.parseEdgeItems)(edgeItems));
+  graph.validate();
+  return graph;
+}
+__name(createGraphFromEdgeItems, "createGraphFromEdgeItems");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_ROUTE,
+  Edge,
+  Graph,
+  createGraphFromEdgeItems,
+  isEdge
+});

package/dist/cjs/workflow/index.js

@@ -0,0 +1,131 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workflow_exports = {};
+__export(workflow_exports, {
+  BaseNode: () => import_base_node.BaseNode,
+  BranchPath: () => import_branch_path.BranchPath,
+  DEFAULT_ROUTE: () => import_graph.DEFAULT_ROUTE,
+  Edge: () => import_graph.Edge,
+  FunctionNode: () => import_function_node.FunctionNode,
+  Graph: () => import_graph.Graph,
+  JoinNode: () => import_join_node.JoinNode,
+  NodeContext: () => import_node_context.NodeContext,
+  NodeReportedError: () => import_errors.NodeReportedError,
+  NodeSchemaValidationError: () => import_errors.NodeSchemaValidationError,
+  NodeStatus: () => import_node_status.NodeStatus,
+  NodeTimeoutError: () => import_errors.NodeTimeoutError,
+  NodeTool: () => import_node_tool.NodeTool,
+  ParallelWorker: () => import_parallel_worker.ParallelWorker,
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME: () => import_hitl_utils.REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
+  REQUEST_INPUT_FUNCTION_CALL_NAME: () => import_hitl_utils.REQUEST_INPUT_FUNCTION_CALL_NAME,
+  RequestInput: () => import_request_input.RequestInput,
+  START: () => import_base_node.START,
+  ToolNode: () => import_tool_node.ToolNode,
+  Workflow: () => import_workflow.Workflow,
+  WorkflowNode: () => import_node.WorkflowNode,
+  asRunnableRoot: () => import_run_node_as_invocation.asRunnableRoot,
+  commonPrefixOf: () => import_branch_path.commonPrefixOf,
+  createNodeErrorEvent: () => import_node_error_event.createNodeErrorEvent,
+  createNodeState: () => import_node_state.createNodeState,
+  createSubBranch: () => import_branch_path.createSubBranch,
+  isNodeErrorEvent: () => import_node_error_event.isNodeErrorEvent,
+  isNodeReportedError: () => import_errors.isNodeReportedError,
+  isNodeSchemaValidationError: () => import_errors.isNodeSchemaValidationError,
+  isNodeState: () => import_node_state.isNodeState,
+  isNodeTimeoutError: () => import_errors.isNodeTimeoutError,
+  isRequestInput: () => import_request_input.isRequestInput,
+  isRunnableRoot: () => import_run_node_as_invocation.isRunnableRoot,
+  isWorkflow: () => import_workflow.isWorkflow,
+  node: () => import_node.node,
+  normalizeRetryExceptions: () => import_retry_config.normalizeRetryExceptions,
+  prepareRetryConfig: () => import_retry_config.prepareRetryConfig,
+  runNodeAsInvocation: () => import_run_node_as_invocation.runNodeAsInvocation
+});
+module.exports = __toCommonJS(workflow_exports);
+var import_run_node_as_invocation = require("./run_node_as_invocation.js");
+var import_workflow = require("./workflow.js");
+var import_base_node = require("./base_node.js");
+var import_node = require("./node.js");
+var import_function_node = require("./nodes/function_node.js");
+var import_join_node = require("./nodes/join_node.js");
+var import_node_tool = require("./nodes/node_tool.js");
+var import_parallel_worker = require("./nodes/parallel_worker.js");
+var import_tool_node = require("./nodes/tool_node.js");
+var import_graph = require("./graph.js");
+var import_branch_path = require("./branch_path.js");
+var import_node_context = require("./node_context.js");
+var import_node_state = require("./node_state.js");
+var import_node_status = require("./node_status.js");
+var import_request_input = require("./request_input.js");
+var import_hitl_utils = require("./utils/hitl_utils.js");
+var import_retry_config = require("./retry_config.js");
+var import_errors = require("./errors.js");
+var import_node_error_event = require("./node_error_event.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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/cjs/workflow/node.js

@@ -0,0 +1,65 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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 node_exports = {};
+__export(node_exports, {
+  WorkflowNode: () => WorkflowNode,
+  node: () => node
+});
+module.exports = __toCommonJS(node_exports);
+var import_experimental = require("../utils/experimental.js");
+var import_base_node = require("./base_node.js");
+var import_workflow_graph_utils = require("./utils/workflow_graph_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function node(nodeLike, options = {}) {
+  return (0, import_workflow_graph_utils.buildNode)(nodeLike, options);
+}
+__name(node, "node");
+let WorkflowNode = class extends import_base_node.BaseNode {
+  async *runImpl(ctx, input) {
+    yield* this.runNodeImpl(ctx, input);
+  }
+};
+__name(WorkflowNode, "WorkflowNode");
+WorkflowNode = __decorateClass([
+  import_experimental.experimental
+], WorkflowNode);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WorkflowNode,
+  node
+});

package/dist/cjs/workflow/node_builders.js

@@ -0,0 +1,68 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var node_builders_exports = {};
+__export(node_builders_exports, {
+  NODE_BUILDERS: () => NODE_BUILDERS,
+  PARALLEL_WORKER_FACTORY: () => PARALLEL_WORKER_FACTORY
+});
+module.exports = __toCommonJS(node_builders_exports);
+var import_base_tool = require("../tools/base_tool.js");
+var import_function_node = require("./nodes/function_node.js");
+var import_parallel_worker = require("./nodes/parallel_worker.js");
+var import_tool_node = require("./nodes/tool_node.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 import_function_node.FunctionNode(name, handler, options);
+  }, "build")
+};
+const TOOL_BUILDER = {
+  match: /* @__PURE__ */ __name((value) => (0, import_base_tool.isBaseTool)(value), "match"),
+  build: /* @__PURE__ */ __name((value, options) => new import_tool_node.ToolNode(value, options), "build")
+};
+const NODE_BUILDERS = [
+  FUNCTION_BUILDER,
+  TOOL_BUILDER
+];
+const PARALLEL_WORKER_FACTORY = /* @__PURE__ */ __name((inner, options) => new import_parallel_worker.ParallelWorker(inner, options), "PARALLEL_WORKER_FACTORY");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NODE_BUILDERS,
+  PARALLEL_WORKER_FACTORY
+});