@google/adk 1.5.0 → 2.0.0

package/dist/cjs/workflow/node_runner.js

@@ -0,0 +1,459 @@
+/**
+  * @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_runner_exports = {};
+__export(node_runner_exports, {
+  executeChildNode: () => executeChildNode
+});
+module.exports = __toCommonJS(node_runner_exports);
+var import_api = require("@opentelemetry/api");
+var import_invocation_context = require("../agents/invocation_context.js");
+var import_event = require("../events/event.js");
+var import_tracing = require("../telemetry/tracing.js");
+var import_error_utils = require("../utils/error_utils.js");
+var import_branch_path = require("./branch_path.js");
+var import_errors = require("./errors.js");
+var import_node_context = require("./node_context.js");
+var import_node_error_event = require("./node_error_event.js");
+var import_node_state = require("./node_state.js");
+var import_node_status = require("./node_status.js");
+var import_retry_utils = require("./utils/retry_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function executeChildNode(params) {
+  var _a, _b;
+  const { parent, node, options = {} } = params;
+  const nodeName = (_a = options.nodeName) != null ? _a : node.name;
+  const nodePath = (_b = options.overrideNodePath) != null ? _b : parent.nodePath ? `${parent.nodePath}.${nodeName}` : nodeName;
+  const span = import_tracing.tracer.startSpan(`execute_node ${nodeName}`);
+  return import_api.context.with(
+    import_api.trace.setSpan(import_api.context.active(), span),
+    () => runChildNode({ params, nodeName, nodePath, span })
+  );
+}
+__name(executeChildNode, "executeChildNode");
+async function runChildNode({
+  params: {
+    parent,
+    node,
+    input,
+    options = {},
+    abortSignal,
+    nodeState: callerNodeState,
+    resumeInputs
+  },
+  nodeName,
+  nodePath,
+  span
+}) {
+  var _a, _b, _c, _d;
+  const runId = (_a = options.runId) != null ? _a : nodeName;
+  let branch = parent.branch;
+  if (options.overrideBranch !== void 0) {
+    branch = options.overrideBranch;
+  } else if (options.useSubBranch) {
+    branch = (0, import_branch_path.createSubBranch)(parent.branch, {
+      name: nodeName,
+      runId: options.runId
+    });
+  }
+  const declaredScope = node.isolationScope === true ? `${nodePath}@${runId}` : node.isolationScope;
+  const isolationScope = (_c = (_b = options.overrideIsolationScope) != null ? _b : declaredScope) != null ? _c : parent.isolationScope;
+  const effectiveAbortSignal = abortSignal != null ? abortSignal : parent.invocationContext.abortSignal;
+  const childIc = branch === parent.invocationContext.branch && effectiveAbortSignal === parent.invocationContext.abortSignal && isolationScope === parent.invocationContext.isolationScope ? parent.invocationContext : new import_invocation_context.InvocationContext({
+    ...parent.invocationContext,
+    branch,
+    abortSignal: effectiveAbortSignal,
+    isolationScope
+  });
+  const child = new import_node_context.NodeContext({
+    invocationContext: childIc,
+    channel: parent.channel,
+    nodePath,
+    runId,
+    resumeInputs: resumeInputs != null ? resumeInputs : parent.resumeInputs,
+    isolationScope,
+    // A node's own schema wins; otherwise it answers to its parent's.
+    stateSchema: (_d = node.stateSchema) != null ? _d : parent.stateSchema
+  });
+  child.scheduler = parent.scheduler;
+  if (options.useAsOutput) {
+    child.outputForAncestors = [
+      parent.nodePath,
+      ...parent.outputForAncestors
+    ].filter((path) => path !== "");
+  }
+  const nodeState = callerNodeState != null ? callerNodeState : (0, import_node_state.createNodeState)({
+    status: import_node_status.NodeStatus.RUNNING,
+    input,
+    runId
+  });
+  const pluginManager = child.invocationContext.pluginManager;
+  try {
+    if (pluginManager == null ? void 0 : pluginManager.hasPlugins) {
+      const skipOutput = await pluginManager.runBeforeNodeCallback({
+        node,
+        nodeContext: child,
+        input
+      });
+      if (skipOutput !== void 0) {
+        child.output = skipOutput;
+        (0, import_tracing.traceNodeExecution)({
+          nodePath,
+          runId,
+          attempt: nodeState.attemptCount,
+          status: "completed",
+          interruptCount: child.interruptIds.length
+        });
+        if (options.useAsOutput) {
+          parent.output = child.output;
+          parent.route = child.route;
+        }
+        return child;
+      }
+    }
+    let succeeded = false;
+    let inputRecorded = false;
+    while (!succeeded) {
+      resetState(child);
+      child.attemptCount = nodeState.attemptCount;
+      try {
+        inputRecorded = await runAttempt({
+          node,
+          child,
+          input,
+          nodeName,
+          branch,
+          isolationScope,
+          nodePath,
+          runId,
+          attempt: nodeState.attemptCount
+        });
+        failIfNodeReportedError(child, nodeName);
+        succeeded = true;
+      } catch (err) {
+        if ((0, import_errors.isNodeInterruptedError)(err)) {
+          succeeded = true;
+          break;
+        }
+        if ((0, import_errors.isInvocationAbortedError)(err)) {
+          throw err;
+        }
+        if ((0, import_errors.isDynamicNodeFailError)(err)) {
+          throw err;
+        }
+        const retryConfig = node.preparedRetryConfig;
+        if (!retryConfig || !(0, import_retry_utils.shouldRetryNode)({ error: err, retryConfig, nodeState })) {
+          throw err;
+        }
+        const delaySeconds = (0, import_retry_utils.getRetryDelaySeconds)({ retryConfig, nodeState });
+        nodeState.attemptCount += 1;
+        await delay(delaySeconds * 1e3, effectiveAbortSignal);
+      }
+    }
+    if (!inputRecorded && child.interruptIds.length > 0) {
+      recordInputForResume({ child, nodeName, branch, isolationScope, input });
+    }
+    (0, import_tracing.traceNodeExecution)({
+      nodePath,
+      runId,
+      attempt: nodeState.attemptCount,
+      status: child.interruptIds.length > 0 ? "waiting" : "completed",
+      interruptCount: child.interruptIds.length
+    });
+    if (pluginManager == null ? void 0 : pluginManager.hasPlugins) {
+      const replacedOutput = await pluginManager.runAfterNodeCallback({
+        node,
+        nodeContext: child,
+        output: child.output
+      });
+      if (replacedOutput !== void 0) {
+        child.output = replacedOutput;
+      }
+    }
+    if (options.useAsOutput) {
+      parent.output = child.output;
+      parent.route = child.route;
+      parent.outputDelegated = true;
+    }
+    return child;
+  } catch (err) {
+    (0, import_tracing.traceNodeExecution)({
+      nodePath,
+      runId,
+      attempt: nodeState.attemptCount,
+      status: "failed",
+      interruptCount: child.interruptIds.length
+    });
+    span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: (0, import_error_utils.formatError)(err) });
+    throw err;
+  } finally {
+    span.end();
+  }
+}
+__name(runChildNode, "runChildNode");
+function runAttempt(params) {
+  const { node, nodePath, runId, attempt } = params;
+  if (!node.preparedRetryConfig) {
+    return runOnce(params);
+  }
+  return import_tracing.tracer.startActiveSpan(
+    `execute_node_attempt ${params.nodeName}`,
+    async (span) => {
+      try {
+        const inputRecorded = await runOnce(params);
+        (0, import_tracing.traceNodeExecution)({
+          nodePath,
+          runId,
+          attempt,
+          status: params.child.interruptIds.length > 0 ? "waiting" : "completed",
+          interruptCount: params.child.interruptIds.length
+        });
+        return inputRecorded;
+      } catch (err) {
+        (0, import_tracing.traceNodeExecution)({
+          nodePath,
+          runId,
+          attempt,
+          status: "failed",
+          interruptCount: params.child.interruptIds.length
+        });
+        span.setStatus({
+          code: import_api.SpanStatusCode.ERROR,
+          message: (0, import_error_utils.formatError)(err)
+        });
+        throw err;
+      } finally {
+        span.end();
+      }
+    }
+  );
+}
+__name(runAttempt, "runAttempt");
+function failIfNodeReportedError(child, nodeName) {
+  const reported = child.reportedError;
+  if (!reported || child.output !== void 0 || child.route !== void 0 || child.interruptIds.length > 0) {
+    return;
+  }
+  const error = new import_errors.NodeReportedError({ nodeName, ...reported });
+  (0, import_node_error_event.claimNodeErrorReport)(error, child.invocationId);
+  throw error;
+}
+__name(failIfNodeReportedError, "failIfNodeReportedError");
+function resetState(childNodeContext) {
+  childNodeContext.output = void 0;
+  childNodeContext.route = void 0;
+  childNodeContext.interruptIds = [];
+  childNodeContext.reportedError = void 0;
+  for (const key of Object.keys(childNodeContext.actions.stateDelta)) {
+    delete childNodeContext.actions.stateDelta[key];
+  }
+}
+__name(resetState, "resetState");
+async function runOnce({
+  node,
+  child,
+  input,
+  nodeName,
+  branch,
+  isolationScope
+}) {
+  var _a;
+  let inputRecorded = false;
+  const consume = /* @__PURE__ */ __name((event) => {
+    var _a2, _b, _c;
+    enrichEvent({ event, child, nodeName, branch, isolationScope });
+    const emittedDelta = (_a2 = event.actions) == null ? void 0 : _a2.stateDelta;
+    if (emittedDelta && emittedDelta !== child.actions.stateDelta) {
+      child.state.validateDelta(emittedDelta);
+    }
+    if (event.output !== void 0) {
+      child.output = event.output;
+      if (child.outputDelegated) {
+        const stateDelta = (_b = event.actions) == null ? void 0 : _b.stateDelta;
+        if (!stateDelta || Object.keys(stateDelta).length === 0) {
+          return;
+        }
+        event.output = void 0;
+        event.content = void 0;
+      }
+    }
+    if (event.route !== void 0) {
+      child.route = event.route;
+    }
+    if (event.errorCode !== void 0 && !(0, import_node_error_event.isNodeErrorEvent)(event)) {
+      child.reportedError = {
+        errorCode: event.errorCode,
+        errorMessage: event.errorMessage
+      };
+    }
+    if (event.longRunningToolIds && event.longRunningToolIds.length > 0) {
+      for (const id of event.longRunningToolIds) {
+        if (!child.interruptIds.includes(id)) {
+          child.interruptIds.push(id);
+        }
+      }
+      event.actions.agentState = {
+        ...(_c = event.actions.agentState) != null ? _c : {},
+        input
+      };
+      inputRecorded = true;
+    }
+    child.channel.push(event);
+  }, "consume");
+  const parentSignal = child.invocationContext.abortSignal;
+  const hasTimeout = typeof node.timeout === "number" && node.timeout > 0;
+  if (!hasTimeout && !parentSignal) {
+    for await (const event of node.run(child, input)) {
+      consume(event);
+    }
+    return inputRecorded;
+  }
+  if (!hasTimeout) {
+    child.abortSignal = parentSignal;
+    try {
+      for await (const event of node.run(child, input)) {
+        consume(event);
+      }
+    } finally {
+      child.abortSignal = void 0;
+    }
+    return inputRecorded;
+  }
+  const timeoutSeconds = node.timeout;
+  const controller = new AbortController();
+  const onParentAbort = /* @__PURE__ */ __name(() => controller.abort(), "onParentAbort");
+  if (parentSignal == null ? void 0 : parentSignal.aborted) {
+    controller.abort();
+  } else {
+    parentSignal == null ? void 0 : parentSignal.addEventListener("abort", onParentAbort, { once: true });
+  }
+  let deadlineFired = false;
+  const timer = setTimeout(
+    () => {
+      deadlineFired = true;
+      controller.abort();
+    },
+    (timeoutSeconds != null ? timeoutSeconds : 0) * 1e3
+  );
+  child.abortSignal = controller.signal;
+  const aborted = new Promise((_, reject) => {
+    const fail = /* @__PURE__ */ __name(() => reject(
+      deadlineFired ? new import_errors.NodeTimeoutError({ nodeName, timeout: timeoutSeconds != null ? timeoutSeconds : 0 }) : new import_errors.InvocationAbortedError(
+        `Invocation aborted while running node '${nodeName}'.`
+      )
+    ), "fail");
+    if (controller.signal.aborted) {
+      fail();
+    } else {
+      controller.signal.addEventListener("abort", fail, { once: true });
+    }
+  });
+  const iterator = node.run(child, input)[Symbol.asyncIterator]();
+  try {
+    let result = await Promise.race([iterator.next(), aborted]);
+    while (!result.done) {
+      consume(result.value);
+      result = await Promise.race([iterator.next(), aborted]);
+    }
+  } finally {
+    clearTimeout(timer);
+    parentSignal == null ? void 0 : parentSignal.removeEventListener("abort", onParentAbort);
+    child.abortSignal = void 0;
+    void Promise.resolve((_a = iterator.return) == null ? void 0 : _a.call(iterator, void 0)).catch(() => {
+    });
+  }
+  return inputRecorded;
+}
+__name(runOnce, "runOnce");
+function recordInputForResume({
+  child,
+  nodeName,
+  branch,
+  isolationScope,
+  input
+}) {
+  const event = (0, import_event.createEvent)({
+    author: nodeName,
+    invocationId: child.invocationId,
+    branch,
+    longRunningToolIds: [...child.interruptIds],
+    actions: { agentState: { input } }
+  });
+  enrichEvent({ event, child, nodeName, branch, isolationScope });
+  child.channel.push(event);
+}
+__name(recordInputForResume, "recordInputForResume");
+function enrichEvent({
+  event,
+  child,
+  nodeName,
+  branch,
+  isolationScope
+}) {
+  var _a;
+  if (!event.author) {
+    event.author = nodeName;
+  }
+  if (!event.invocationId) {
+    event.invocationId = child.invocationId;
+  }
+  event.nodeInfo = { ...(_a = event.nodeInfo) != null ? _a : {}, path: child.nodePath };
+  if (event.output !== void 0) {
+    event.nodeInfo.outputFor = [child.nodePath, ...child.outputForAncestors];
+  }
+  if (branch !== void 0 && event.branch === void 0) {
+    event.branch = branch;
+  }
+  if (isolationScope !== void 0 && event.isolationScope === void 0) {
+    event.isolationScope = isolationScope;
+  }
+}
+__name(enrichEvent, "enrichEvent");
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal == null ? void 0 : signal.aborted) {
+      reject(new import_errors.InvocationAbortedError("Invocation aborted during retry."));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = /* @__PURE__ */ __name(() => {
+      clearTimeout(timer);
+      reject(new import_errors.InvocationAbortedError("Invocation aborted during retry."));
+    }, "onAbort");
+    signal == null ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+__name(delay, "delay");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  executeChildNode
+});

package/dist/cjs/workflow/node_state.js

@@ -0,0 +1,57 @@
+/**
+  * @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_state_exports = {};
+__export(node_state_exports, {
+  createNodeState: () => createNodeState,
+  isNodeState: () => isNodeState
+});
+module.exports = __toCommonJS(node_state_exports);
+var import_node_status = require("./node_status.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function createNodeState(partial) {
+  return {
+    status: import_node_status.NodeStatus.INACTIVE,
+    attemptCount: 1,
+    interrupts: [],
+    resumeInputs: {},
+    runCounter: 0,
+    ...partial
+  };
+}
+__name(createNodeState, "createNodeState");
+function isNodeState(obj) {
+  return typeof obj === "object" && obj !== null && "status" in obj && typeof obj.status === "number" && "attemptCount" in obj && "interrupts" in obj && Array.isArray(obj.interrupts);
+}
+__name(isNodeState, "isNodeState");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNodeState,
+  isNodeState
+});

package/dist/cjs/workflow/node_status.js

@@ -0,0 +1,48 @@
+/**
+  * @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 node_status_exports = {};
+__export(node_status_exports, {
+  NodeStatus: () => NodeStatus
+});
+module.exports = __toCommonJS(node_status_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var NodeStatus = /* @__PURE__ */ ((NodeStatus2) => {
+  NodeStatus2[NodeStatus2["INACTIVE"] = 0] = "INACTIVE";
+  NodeStatus2[NodeStatus2["PENDING"] = 1] = "PENDING";
+  NodeStatus2[NodeStatus2["RUNNING"] = 2] = "RUNNING";
+  NodeStatus2[NodeStatus2["COMPLETED"] = 3] = "COMPLETED";
+  NodeStatus2[NodeStatus2["WAITING"] = 4] = "WAITING";
+  NodeStatus2[NodeStatus2["FAILED"] = 5] = "FAILED";
+  NodeStatus2[NodeStatus2["CANCELLED"] = 6] = "CANCELLED";
+  return NodeStatus2;
+})(NodeStatus || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NodeStatus
+});