@google/adk 2.0.0 → 2.2.0

package/dist/web/workflow/node_runner.js

@@ -1,481 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { context, SpanStatusCode, trace } from "@opentelemetry/api";
-import { InvocationContext } from "../agents/invocation_context.js";
-import { createEvent } from "../events/event.js";
-import { traceNodeExecution, tracer } from "../telemetry/tracing.js";
-import { formatError } from "../utils/error_utils.js";
-import { createSubBranch } from "./branch_path.js";
-import {
-  InvocationAbortedError,
-  isDynamicNodeFailError,
-  isInvocationAbortedError,
-  isNodeInterruptedError,
-  NodeReportedError,
-  NodeTimeoutError
-} from "./errors.js";
-import { NodeContext } from "./node_context.js";
-import { claimNodeErrorReport, isNodeErrorEvent } from "./node_error_event.js";
-import { createNodeState } from "./node_state.js";
-import { NodeStatus } from "./node_status.js";
-import { getRetryDelaySeconds, shouldRetryNode } from "./utils/retry_utils.js";
-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 ? "".concat(parent.nodePath, ".").concat(nodeName) : nodeName;
-  const span = tracer.startSpan("execute_node ".concat(nodeName));
-  return context.with(
-    trace.setSpan(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 = createSubBranch(parent.branch, {
-      name: nodeName,
-      runId: options.runId
-    });
-  }
-  const declaredScope = node.isolationScope === true ? "".concat(nodePath, "@").concat(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 InvocationContext(__spreadProps(__spreadValues({}, parent.invocationContext), {
-    branch,
-    abortSignal: effectiveAbortSignal,
-    isolationScope
-  }));
-  const child = new 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 : createNodeState({
-    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;
-        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 (isNodeInterruptedError(err)) {
-          succeeded = true;
-          break;
-        }
-        if (isInvocationAbortedError(err)) {
-          throw err;
-        }
-        if (isDynamicNodeFailError(err)) {
-          throw err;
-        }
-        const retryConfig = node.preparedRetryConfig;
-        if (!retryConfig || !shouldRetryNode({ error: err, retryConfig, nodeState })) {
-          throw err;
-        }
-        const delaySeconds = getRetryDelaySeconds({ retryConfig, nodeState });
-        nodeState.attemptCount += 1;
-        await delay(delaySeconds * 1e3, effectiveAbortSignal);
-      }
-    }
-    if (!inputRecorded && child.interruptIds.length > 0) {
-      recordInputForResume({ child, nodeName, branch, isolationScope, input });
-    }
-    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) {
-    traceNodeExecution({
-      nodePath,
-      runId,
-      attempt: nodeState.attemptCount,
-      status: "failed",
-      interruptCount: child.interruptIds.length
-    });
-    span.setStatus({ code: SpanStatusCode.ERROR, message: 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 tracer.startActiveSpan(
-    "execute_node_attempt ".concat(params.nodeName),
-    async (span) => {
-      try {
-        const inputRecorded = await runOnce(params);
-        traceNodeExecution({
-          nodePath,
-          runId,
-          attempt,
-          status: params.child.interruptIds.length > 0 ? "waiting" : "completed",
-          interruptCount: params.child.interruptIds.length
-        });
-        return inputRecorded;
-      } catch (err) {
-        traceNodeExecution({
-          nodePath,
-          runId,
-          attempt,
-          status: "failed",
-          interruptCount: params.child.interruptIds.length
-        });
-        span.setStatus({
-          code: SpanStatusCode.ERROR,
-          message: 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 NodeReportedError(__spreadValues({ nodeName }, reported));
-  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 && !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 = __spreadProps(__spreadValues({}, (_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) {
-    try {
-      for (var iter = __forAwait(node.run(child, input)), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
-        const event = temp.value;
-        consume(event);
-      }
-    } catch (temp) {
-      error = [temp];
-    } finally {
-      try {
-        more && (temp = iter.return) && await temp.call(iter);
-      } finally {
-        if (error)
-          throw error[0];
-      }
-    }
-    return inputRecorded;
-  }
-  if (!hasTimeout) {
-    child.abortSignal = parentSignal;
-    try {
-      try {
-        for (var iter2 = __forAwait(node.run(child, input)), more2, temp2, error2; more2 = !(temp2 = await iter2.next()).done; more2 = false) {
-          const event = temp2.value;
-          consume(event);
-        }
-      } catch (temp2) {
-        error2 = [temp2];
-      } finally {
-        try {
-          more2 && (temp2 = iter2.return) && await temp2.call(iter2);
-        } finally {
-          if (error2)
-            throw error2[0];
-        }
-      }
-    } 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 NodeTimeoutError({ nodeName, timeout: timeoutSeconds != null ? timeoutSeconds : 0 }) : new InvocationAbortedError(
-        "Invocation aborted while running node '".concat(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 = 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 = __spreadProps(__spreadValues({}, (_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 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 InvocationAbortedError("Invocation aborted during retry."));
-    }, "onAbort");
-    signal == null ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-__name(delay, "delay");
-export {
-  executeChildNode
-};

package/dist/web/workflow/node_state.js

@@ -1,43 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { NodeStatus } from "./node_status.js";
-function createNodeState(partial) {
-  return __spreadValues({
-    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");
-export {
-  createNodeState,
-  isNodeState
-};

package/dist/web/workflow/node_status.js

@@ -1,20 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @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 || {});
-export {
-  NodeStatus
-};