@google/adk 1.6.0 → 2.1.0

package/dist/esm/workflow/dynamic_node_scheduler.js

@@ -0,0 +1,202 @@
+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 {
+  DynamicNodeFailError,
+  isDynamicNodeFailError,
+  isNodeInterruptedError
+} from "./errors.js";
+import { executeChildNode } from "./node_runner.js";
+import { createNodeState } from "./node_state.js";
+import { NodeStatus } from "./node_status.js";
+import {
+  eventsForCurrentRun,
+  isFastForwardable,
+  makeFastForwardResult,
+  reconstructNodeStatesByPath
+} from "./utils/rehydration_utils.js";
+const _DynamicNodeScheduler = class _DynamicNodeScheduler {
+  /**
+   * @param state Shared dynamic-node bookkeeping for this workflow subtree.
+   * @param abortSignal Workflow-scoped cancellation signal, forwarded to each
+   *   dynamic child so a workflow shutting down on error can cancel in-flight
+   *   `ctx.runNode()` children too.
+   */
+  constructor(state, abortSignal) {
+    this.state = state;
+    this.abortSignal = abortSignal;
+  }
+  /**
+   * Runs a `ctx.runNode()` call and reports any interrupt it is still waiting
+   * on to the caller's own context.
+   *
+   * A child's interrupt is the caller's problem: the caller cannot produce a
+   * trustworthy result until the human answers, and until the engine knows the
+   * caller is waiting it marks it COMPLETED and schedules its successor —
+   * which then runs on the `undefined` the caller returned when it bailed out.
+   * `ParallelWorker` has always copied its items' interrupt ids onto its own
+   * context for exactly this reason; doing it here extends that to every
+   * caller instead of only the one that remembered.
+   *
+   * Only unresolved interrupts arrive here. A child fast-forwarded from a
+   * checkpoint, or handed a resolved reply as its output, reports none.
+   */
+  async schedule(ctx, node, input, options) {
+    const result = await this.scheduleRun(ctx, node, input, options);
+    for (const id of result.interruptIds) {
+      if (!ctx.interruptIds.includes(id)) {
+        ctx.interruptIds.push(id);
+      }
+    }
+    return result;
+  }
+  async scheduleRun(ctx, node, input, options) {
+    var _a, _b, _c;
+    const name = (_a = options.nodeName) != null ? _a : node.name;
+    const runId = options.runId;
+    const nodePath = ctx.nodePath ? `${ctx.nodePath}.${name}@${runId}` : `${name}@${runId}`;
+    const existing = this.state.runs.get(nodePath);
+    if (existing == null ? void 0 : existing.task) {
+      return existing.task;
+    }
+    if (existing == null ? void 0 : existing.result) {
+      return this.handBack(ctx, existing.result, options);
+    }
+    if (!this.state.runs.has(nodePath)) {
+      const prior = reconstructNodeStatesByPath(
+        eventsForCurrentRun((_c = (_b = ctx.session) == null ? void 0 : _b.events) != null ? _c : [], ctx.invocationId)
+      ).get(nodePath);
+      if (prior && isFastForwardable(prior)) {
+        return this.completeWithoutRunning(
+          ctx,
+          { nodePath, runId, options },
+          makeFastForwardResult(ctx, prior)
+        );
+      }
+      const handoff = this.resumeHandoff(ctx, node, prior);
+      if (handoff) {
+        return this.completeWithoutRunning(
+          ctx,
+          { nodePath, runId, options },
+          handoff
+        );
+      }
+    }
+    return this.runFresh(ctx, node, input, name, runId, nodePath, options);
+  }
+  /**
+   * Books a dynamic run that completed WITHOUT executing its body — either
+   * fast-forwarded from a cached output or handed the resolved resume value —
+   * and returns `result` for `ctx.runNode()` to give back to the caller.
+   */
+  completeWithoutRunning(ctx, run, result) {
+    this.state.runs.set(run.nodePath, {
+      state: createNodeState({
+        status: NodeStatus.COMPLETED,
+        runId: run.runId,
+        parentRunId: ctx.runId
+      }),
+      output: result.output,
+      result
+    });
+    return this.handBack(ctx, result, run.options);
+  }
+  /**
+   * Applies a settled result to the caller's context and returns it, so a first
+   * call and a repeat call for the same path are indistinguishable.
+   */
+  handBack(ctx, result, options) {
+    if (options.useAsOutput) {
+      ctx.output = result.output;
+      ctx.route = result.route;
+    }
+    return result;
+  }
+  /**
+   * Builds the completion result for a child that interrupted in a prior turn
+   * and whose interrupts are now all resolved, or `undefined` when the child is
+   * not in that state (so the caller falls through to a fresh run).
+   */
+  resumeHandoff(ctx, node, prior) {
+    var _a;
+    if (!prior || node.rerunOnResume || prior.output !== void 0 || prior.interruptIds.size === 0) {
+      return void 0;
+    }
+    const values = [...prior.interruptIds].map((id) => ctx.resumeInputs[id]);
+    if (!values.every((value) => value !== void 0)) {
+      return void 0;
+    }
+    return {
+      output: values.length === 1 ? values[0] : values,
+      route: void 0,
+      branch: (_a = prior.branch) != null ? _a : ctx.branch,
+      interruptIds: []
+    };
+  }
+  async runFresh(ctx, node, input, name, runId, nodePath, options) {
+    const run = {
+      state: createNodeState({
+        status: NodeStatus.RUNNING,
+        input,
+        runId,
+        parentRunId: ctx.runId
+      })
+    };
+    this.state.runs.set(nodePath, run);
+    run.task = executeChildNode({
+      parent: ctx,
+      node,
+      input,
+      abortSignal: this.abortSignal,
+      options: {
+        nodeName: name,
+        runId,
+        overrideNodePath: nodePath,
+        useAsOutput: options.useAsOutput,
+        useSubBranch: options.useSubBranch,
+        overrideBranch: options.overrideBranch,
+        overrideIsolationScope: options.overrideIsolationScope
+      }
+    });
+    let childCtx;
+    try {
+      childCtx = await run.task;
+    } catch (err) {
+      if (isNodeInterruptedError(err) || isDynamicNodeFailError(err)) {
+        throw err;
+      }
+      run.state.status = NodeStatus.FAILED;
+      const error = err instanceof Error ? err : new Error(String(err));
+      throw new DynamicNodeFailError({
+        message: `Dynamic node ${name} failed: ${error.message}`,
+        error,
+        errorNodePath: nodePath
+      });
+    }
+    this.recordResult(run, childCtx, node);
+    return childCtx;
+  }
+  recordResult(run, childCtx, node) {
+    if (childCtx.interruptIds.length > 0) {
+      run.state.status = NodeStatus.WAITING;
+      run.state.interrupts = [...childCtx.interruptIds];
+      childCtx.interruptIds.forEach((id) => this.state.interruptIds.add(id));
+    } else if (node.waitForOutput && childCtx.output === void 0 && childCtx.route === void 0) {
+      run.state.status = NodeStatus.WAITING;
+    } else {
+      run.state.status = NodeStatus.COMPLETED;
+      run.output = childCtx.output;
+    }
+  }
+};
+__name(_DynamicNodeScheduler, "DynamicNodeScheduler");
+let DynamicNodeScheduler = _DynamicNodeScheduler;
+export {
+  DynamicNodeScheduler
+};

package/dist/esm/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 '${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");
+export {
+  DynamicNodeFailError,
+  InvocationAbortedError,
+  NodeInterruptedError,
+  NodeReportedError,
+  NodeSchemaValidationError,
+  NodeTimeoutError,
+  isDynamicNodeFailError,
+  isInvocationAbortedError,
+  isNodeInterruptedError,
+  isNodeReportedError,
+  isNodeSchemaValidationError,
+  isNodeTimeoutError
+};

package/dist/esm/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 = /* @__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(", ");
+        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 = 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/esm/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/esm/workflow/node.js

@@ -0,0 +1,38 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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;
+};
+/**
+ * @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 {
+  async *runImpl(ctx, input) {
+    yield* this.runNodeImpl(ctx, input);
+  }
+};
+__name(WorkflowNode, "WorkflowNode");
+WorkflowNode = __decorateClass([
+  experimental
+], WorkflowNode);
+export {
+  WorkflowNode,
+  node
+};

package/dist/esm/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
+};