@google/adk 2.0.0 → 2.2.0

package/dist/web/workflow/base_node.js

@@ -1,215 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __await = function(promise, isYieldStar) {
-  this[0] = promise;
-  this[1] = isYieldStar;
-};
-var __asyncGenerator = (__this, __arguments, generator) => {
-  var resume = (k, v, yes, no) => {
-    try {
-      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
-      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
-    } catch (e) {
-      no(e);
-    }
-  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
-  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
-};
-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
- */
-var _a;
-import { createModelContent } from "@google/genai";
-import { createEvent, isEvent } from "../events/event.js";
-import { parseWithSchema } from "../utils/schema.js";
-import { NodeSchemaValidationError } from "./errors.js";
-import { isRequestInput } from "./request_input.js";
-import {
-  prepareRetryConfig
-} from "./retry_config.js";
-import { createRequestInputEvent } from "./utils/hitl_utils.js";
-const BASE_NODE_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.baseNode");
-_a = BASE_NODE_SIGNATURE_SYMBOL;
-const _BaseNode = class _BaseNode {
-  constructor(config) {
-    /** Brand identifying this object as a {@link BaseNode} (see `isBaseNode`). */
-    this[_a] = true;
-    var _a2, _b, _c;
-    if (!config.name || typeof config.name !== "string" || config.name.trim().length === 0) {
-      throw new Error("Node name must be a non-empty string.");
-    }
-    this.name = config.name.trim();
-    this.description = (_a2 = config.description) != null ? _a2 : "";
-    this.rerunOnResume = (_b = config.rerunOnResume) != null ? _b : false;
-    this.waitForOutput = (_c = config.waitForOutput) != null ? _c : false;
-    this.retryConfig = config.retryConfig;
-    this.preparedRetryConfig = config.retryConfig ? prepareRetryConfig(config.retryConfig) : void 0;
-    this.timeout = config.timeout;
-    this.inputSchema = config.inputSchema;
-    this.outputSchema = config.outputSchema;
-    this.stateSchema = config.stateSchema;
-    this.isolationScope = config.isolationScope;
-  }
-  /**
-   * Whether this node must wait for ALL of its predecessors to trigger before
-   * it runs (fan-in barrier). Overridden by `JoinNode`.
-   */
-  get requiresAllPredecessors() {
-    return false;
-  }
-  /**
-   * Runs the node, normalizing every yielded item into an {@link Event}. This
-   * is what the engine (and `ctx.runNode()`) consumes. Validates the input
-   * against `inputSchema` once, up front (skipping genai `Content`, which nodes
-   * coerce themselves).
-   */
-  run(ctx, input) {
-    return __asyncGenerator(this, null, function* () {
-      const validatedInput = this.validateInput(input);
-      try {
-        for (var iter = __forAwait(this.runImpl(ctx, validatedInput)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-          const item = temp.value;
-          if (isRequestInput(item)) {
-            yield createRequestInputEvent(item);
-            continue;
-          }
-          const event = this.toEvent(ctx, item);
-          if (event) {
-            yield event;
-          }
-        }
-      } catch (temp) {
-        error = [temp];
-      } finally {
-        try {
-          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-        } finally {
-          if (error)
-            throw error[0];
-        }
-      }
-    });
-  }
-  /**
-   * Validates node input against `inputSchema` (Content passes through). Only
-   * enforced for Zod schemas; a genai `Schema` is left unvalidated (see
-   * `parseWithSchema`).
-   */
-  validateInput(input) {
-    if (isContent(input)) {
-      return input;
-    }
-    try {
-      return parseWithSchema(this.inputSchema, input);
-    } catch (e) {
-      throw new NodeSchemaValidationError({
-        nodeName: this.name,
-        direction: "input",
-        cause: e
-      });
-    }
-  }
-  /**
-   * Validates node output against `outputSchema` (Content passes through). Only
-   * enforced for Zod schemas; a genai `Schema` is left unvalidated (see
-   * `parseWithSchema`).
-   */
-  validateOutput(output) {
-    if (isContent(output)) {
-      return output;
-    }
-    try {
-      return parseWithSchema(this.outputSchema, output);
-    } catch (e) {
-      throw new NodeSchemaValidationError({
-        nodeName: this.name,
-        direction: "output",
-        cause: e
-      });
-    }
-  }
-  /**
-   * Normalizes a single yielded item into an {@link Event} (or `null` to skip).
-   * Subclasses may override for richer coercion (e.g. `FunctionNode`).
-   */
-  toEvent(ctx, data) {
-    if (data === null || data === void 0) {
-      return null;
-    }
-    if (isEvent(data)) {
-      const event = data;
-      if (event.output !== void 0) {
-        event.output = this.validateOutput(event.output);
-      }
-      return event;
-    }
-    const output = this.validateOutput(data);
-    return createEvent({
-      author: this.name,
-      invocationId: ctx.invocationContext.invocationId,
-      branch: ctx.branch,
-      content: toContent(output),
-      output
-    });
-  }
-};
-__name(_BaseNode, "BaseNode");
-let BaseNode = _BaseNode;
-function isBaseNode(value) {
-  return typeof value === "object" && value !== null && BASE_NODE_SIGNATURE_SYMBOL in value && value[BASE_NODE_SIGNATURE_SYMBOL] === true;
-}
-__name(isBaseNode, "isBaseNode");
-function isContent(value) {
-  return typeof value === "object" && value !== null && "parts" in value && Array.isArray(value.parts);
-}
-__name(isContent, "isContent");
-const _StartNode = class _StartNode extends BaseNode {
-  // eslint-disable-next-line require-yield
-  runImpl() {
-    return __asyncGenerator(this, null, function* () {
-      throw new Error("START node is never executed.");
-    });
-  }
-};
-__name(_StartNode, "StartNode");
-let StartNode = _StartNode;
-const START = new StartNode({ name: "__START__" });
-function toContent(val) {
-  if (val === null || val === void 0) {
-    return void 0;
-  }
-  if (isContent(val)) {
-    return val;
-  }
-  try {
-    return createModelContent(val);
-  } catch (e) {
-    return createModelContent(valueToText(val));
-  }
-}
-__name(toContent, "toContent");
-function valueToText(val) {
-  var _a2;
-  if (typeof val === "string") {
-    return val;
-  }
-  try {
-    return (_a2 = JSON.stringify(val)) != null ? _a2 : String(val);
-  } catch (e) {
-    return String(val);
-  }
-}
-__name(valueToText, "valueToText");
-export {
-  BaseNode,
-  START,
-  isBaseNode,
-  isContent,
-  toContent
-};

package/dist/web/workflow/branch_path.js

@@ -1,77 +0,0 @@
-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 _BranchPath = class _BranchPath {
-  constructor(segments) {
-    this.segments = [...segments];
-  }
-  toString() {
-    return this.segments.join(".");
-  }
-  /** Returns a copy of the path segments. */
-  getSegments() {
-    return [...this.segments];
-  }
-  /** Whether this path is a strict descendant of `ancestor`. */
-  isDescendantOf(ancestor) {
-    if (this.segments.length <= ancestor.segments.length) {
-      return false;
-    }
-    return ancestor.segments.every((seg, i) => this.segments[i] === seg);
-  }
-  /** Returns a new path with a `name@runId` (or `name`) segment appended. */
-  append(name, runId) {
-    const segment = runId !== void 0 ? "".concat(name, "@").concat(runId) : name;
-    return new _BranchPath([...this.segments, segment]);
-  }
-};
-__name(_BranchPath, "BranchPath");
-let BranchPath = _BranchPath;
-function branchPathFromString(path) {
-  if (!path) {
-    return new BranchPath([]);
-  }
-  return new BranchPath(path.split("."));
-}
-__name(branchPathFromString, "branchPathFromString");
-function commonPrefixOfPaths(paths) {
-  if (paths.length === 0) {
-    return new BranchPath([]);
-  }
-  const allSegments = paths.map((p) => p.getSegments());
-  const common = [];
-  const minLen = Math.min(...allSegments.map((s) => s.length));
-  for (let i = 0; i < minLen; i++) {
-    const seg = allSegments[0][i];
-    if (allSegments.every((s) => s[i] === seg)) {
-      common.push(seg);
-    } else {
-      break;
-    }
-  }
-  return new BranchPath(common);
-}
-__name(commonPrefixOfPaths, "commonPrefixOfPaths");
-function createSubBranch(baseBranch, options) {
-  return branchPathFromString(baseBranch).append(options.name, options.runId).toString();
-}
-__name(createSubBranch, "createSubBranch");
-function commonPrefixOf(branches) {
-  return commonPrefixOfPaths(
-    branches.map((b) => branchPathFromString(b))
-  ).toString();
-}
-__name(commonPrefixOf, "commonPrefixOf");
-export {
-  BranchPath,
-  branchPathFromString,
-  commonPrefixOf,
-  commonPrefixOfPaths,
-  createSubBranch
-};

package/dist/web/workflow/dynamic_node_scheduler.js

@@ -1,202 +0,0 @@
-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 ? "".concat(ctx.nodePath, ".").concat(name, "@").concat(runId) : "".concat(name, "@").concat(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 ".concat(name, " failed: ").concat(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/web/workflow/errors.js

@@ -1,140 +0,0 @@
-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 '".concat(options.nodeName, "' timed out after ").concat(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 '".concat(options.nodeName, "' failed: ").concat(code === "UNKNOWN_ERROR" ? detail : "".concat(code, ": ").concat(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 '".concat(options.nodeName, "' ").concat(options.direction, " does not match its ") + "".concat(schemaName, ": ").concat(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
-};