@google/adk 1.5.0 → 2.0.0

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 = 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
+};

package/dist/esm/workflow/node_context.js

@@ -0,0 +1,219 @@
+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 { createEventActions } from "../events/event_actions.js";
+import { State } from "../sessions/state.js";
+import { NodeInterruptedError } from "./errors.js";
+import { executeChildNode } from "./node_runner.js";
+import { buildNode } from "./utils/workflow_graph_utils.js";
+const _NodeContext = class _NodeContext {
+  constructor(opts) {
+    /**
+     * Node paths whose output this node's output also becomes: its parent's if
+     * the parent ran it with `useAsOutput`, plus whatever the parent was standing
+     * in for. Stamped onto every output event as `nodeInfo.outputFor`, so a
+     * resumed run can tell that an ancestor already has a result.
+     */
+    this.outputForAncestors = [];
+    /**
+     * Whether this node handed its output to a child run with `useAsOutput`.
+     *
+     * The child already emitted that value as its own result, so an event from
+     * this node repeating it would put the same text in the stream twice. The
+     * node still reports the output — only the duplicate event is suppressed.
+     */
+    this.outputDelegated = false;
+    /** The structured output produced by the node during its run. */
+    this.output = void 0;
+    /** Interrupt ids the node is currently blocked on (HITL). */
+    this.interruptIds = [];
+    /** The current attempt number (1-based) for the running node (see retry). */
+    this.attemptCount = 1;
+    this.dynamicRunCounters = /* @__PURE__ */ new Map();
+    /** Run ids this context handed out automatically, per node name. */
+    this.autoRunIds = /* @__PURE__ */ new Map();
+    /**
+     * Caller-supplied run ids shaped like an automatic one (all digits), per node
+     * name — the set {@link assertNoNumericCustomRunIds} refuses to auto-number
+     * around.
+     */
+    this.numericCustomRunIds = /* @__PURE__ */ new Map();
+    var _a, _b;
+    this.invocationContext = opts.invocationContext;
+    this.channel = opts.channel;
+    this.nodePath = opts.nodePath;
+    this.runId = opts.runId;
+    this.resumeInputs = (_a = opts.resumeInputs) != null ? _a : {};
+    this.isolationScope = opts.isolationScope;
+    this.actions = (_b = opts.actions) != null ? _b : createEventActions();
+    this.stateSchema = opts.stateSchema;
+    this._state = new State(
+      opts.invocationContext.session.state,
+      this.actions.stateDelta,
+      opts.stateSchema
+    );
+  }
+  /** Delta-aware session state; writes accumulate in `actions.stateDelta`. */
+  get state() {
+    return this._state;
+  }
+  /** The branch of the owning invocation context. */
+  get branch() {
+    return this.invocationContext.branch;
+  }
+  /** The current invocation id. */
+  get invocationId() {
+    return this.invocationContext.invocationId;
+  }
+  /** The current session. */
+  get session() {
+    return this.invocationContext.session;
+  }
+  /**
+   * The invocation context to run a nested agent against.
+   *
+   * The single place where "what a node sees" is translated into "what an
+   * agent sees", so an agent run as a node (`BaseAgent.runImpl`) and one run
+   * directly go through the same seam.
+   *
+   * It hands back the node's own invocation context unchanged, and that is the
+   * intended behaviour rather than a placeholder.
+   *
+   * adk-python's counterpart (`agents/context.py` `get_invocation_context`) is
+   * documented as returning "a copy with the proxy session", which reads as
+   * though the agent is handed a different view of state. It is not: that
+   * `Context.session` returns `self._invocation_context.session`, so the copy
+   * substitutes the same object, and `Context._state` is built directly over
+   * `session.state`. A Python agent run as a node reads session state exactly
+   * as a TypeScript one does.
+   *
+   * The other thing that copy carries — the isolation scope — is already
+   * applied by the time this runs: the node runner builds the child invocation
+   * context with the node's scope, so it is present on the object returned.
+   *
+   * That leaves the node's own `state`, which is this node's pending delta over
+   * `session.state` — the same thing an agent reads, so the two cannot
+   * disagree. The agent-node cases in
+   * `core/test/workflow/state_consistency_test.ts` pin that.
+   */
+  getInvocationContext() {
+    return this.invocationContext;
+  }
+  /** Streams a single event out through the workflow's event channel. */
+  emit(event) {
+    this.channel.push(event);
+  }
+  /**
+   * Runs a child node programmatically, streaming its events through the same
+   * channel and resolving to the child's result — a full {@link NodeContext}
+   * for a node that actually ran, or a bare {@link NodeResult} for one that was
+   * fast-forwarded from cached output on resume. Either way the caller can read
+   * `output`, `route`, `branch`, and `interruptIds`; only a `NodeContext`
+   * offers live behaviour (`emit`, `state`, nested `runNode`).
+   *
+   * When a dynamic-node {@link scheduler} is set (inside a Workflow subtree),
+   * the call routes through it for dedup/resume; otherwise the child runs
+   * directly.
+   *
+   * Takes anything an edge takes — an agent, a tool, a plain function, or an
+   * already-built node — and wraps it the same way the graph does, so
+   * `ctx.runNode(myAgent, input)` works without `node(myAgent)`. Wrap it
+   * yourself when you need the options `node()` carries, such as a schema or a
+   * name that differs from the value's own.
+   */
+  runNode(nodeLike, input, options) {
+    var _a, _b;
+    const node = buildNode(nodeLike);
+    if (this.scheduler) {
+      const nodeName = (_a = options == null ? void 0 : options.nodeName) != null ? _a : node.name;
+      let runId = options == null ? void 0 : options.runId;
+      if (runId !== void 0) {
+        assertCustomRunId(runId, nodeName, mapSet(this.autoRunIds, nodeName));
+        if (isAutoNumberShaped(runId)) {
+          mapSet(this.numericCustomRunIds, nodeName).add(runId);
+        }
+      }
+      if (!runId) {
+        assertNoNumericCustomRunIds(
+          nodeName,
+          mapSet(this.numericCustomRunIds, nodeName)
+        );
+        const next = ((_b = this.dynamicRunCounters.get(nodeName)) != null ? _b : 0) + 1;
+        this.dynamicRunCounters.set(nodeName, next);
+        runId = String(next);
+        mapSet(this.autoRunIds, nodeName).add(runId);
+      }
+      return this.scheduleAndUnwind(node, input, {
+        ...options,
+        nodeName,
+        runId
+      });
+    }
+    return executeChildNode({ parent: this, node, input, options });
+  }
+  /**
+   * Runs a child through the scheduler, raising {@link NodeInterruptedError}
+   * when it comes back waiting on an unanswered interrupt.
+   *
+   * The caller's body must not continue past a child that stopped to ask the
+   * user: everything after the call would run on a missing answer, and would
+   * run again when the turn resumes. The scheduler has already copied the
+   * child's interrupt ids onto this context by the time it returns, so the
+   * runner that catches the throw records this node as waiting.
+   */
+  async scheduleAndUnwind(node, input, options) {
+    const child = await this.scheduler.schedule(this, node, input, options);
+    if (child.interruptIds.length > 0) {
+      throw new NodeInterruptedError();
+    }
+    return child;
+  }
+};
+__name(_NodeContext, "NodeContext");
+let NodeContext = _NodeContext;
+function mapSet(map, key) {
+  let set = map.get(key);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    map.set(key, set);
+  }
+  return set;
+}
+__name(mapSet, "mapSet");
+function isAutoNumberShaped(runId) {
+  return /^\d+$/.test(runId);
+}
+__name(isAutoNumberShaped, "isAutoNumberShaped");
+function numericRunIdMixError(nodeName, runId) {
+  return new Error(
+    `Invalid runId '${runId}' for node '${nodeName}': ADK numbers automatic runs of a node "1", "2", "3", \u2026 per context, so an all-digit custom id draws from that same namespace. A later turn that issues a different set of custom ids shifts the automatic sequence onto a checkpoint path an earlier call already wrote, and the call is fast-forwarded to that run's cached output with its own input silently discarded. Give the custom id a non-numeric part, e.g. '${nodeName}-${runId}', or supply an explicit id for every run of this node so ADK never numbers one.`
+  );
+}
+__name(numericRunIdMixError, "numericRunIdMixError");
+function assertCustomRunId(runId, nodeName, autoRunIds) {
+  if (runId.trim() === "") {
+    throw new Error(
+      `Invalid runId for node '${nodeName}': a custom run id cannot be empty. Omit runId to let ADK number the run automatically.`
+    );
+  }
+  if (autoRunIds.size > 0 && isAutoNumberShaped(runId)) {
+    throw numericRunIdMixError(nodeName, runId);
+  }
+}
+__name(assertCustomRunId, "assertCustomRunId");
+function assertNoNumericCustomRunIds(nodeName, numericCustomRunIds) {
+  const first = numericCustomRunIds.values().next();
+  if (!first.done) {
+    throw numericRunIdMixError(nodeName, first.value);
+  }
+}
+__name(assertNoNumericCustomRunIds, "assertNoNumericCustomRunIds");
+export {
+  NodeContext
+};