@google/adk 1.5.0 → 2.0.0

package/dist/esm/workflow/utils/rehydration_utils.js

@@ -0,0 +1,342 @@
+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 { requiresUserInput } from "../../agents/user_input_request.js";
+import {
+  interruptResponseMismatch,
+  REQUEST_INPUT_FUNCTION_CALL_NAME,
+  responseSchemasByInterruptId
+} from "./hitl_utils.js";
+const RESULT_KEY = "result";
+function eventsForCurrentRun(events, currentInvocationId) {
+  var _a;
+  const priorRuns = [];
+  let currentStart = events.length;
+  let lastInvocationId;
+  for (let i = 0; i < events.length; i++) {
+    const event = events[i];
+    const invocationId = event.invocationId || lastInvocationId;
+    if (event.invocationId) {
+      lastInvocationId = event.invocationId;
+    }
+    if (invocationId === currentInvocationId) {
+      if (currentStart === events.length) {
+        currentStart = i;
+      }
+      continue;
+    }
+    if (!((_a = event.nodeInfo) == null ? void 0 : _a.path)) {
+      continue;
+    }
+    let entry = priorRuns[priorRuns.length - 1];
+    if (!entry || entry.invocationId !== invocationId) {
+      entry = { start: i, invocationId, paused: false };
+      priorRuns.push(entry);
+    }
+    if (raisedInterrupt(event)) {
+      entry.paused = true;
+    }
+  }
+  let boundary = currentStart;
+  for (let i = priorRuns.length - 1; i >= 0 && priorRuns[i].paused; i--) {
+    boundary = priorRuns[i].start;
+  }
+  return events.slice(boundary);
+}
+__name(eventsForCurrentRun, "eventsForCurrentRun");
+function raisedInterrupt(event) {
+  return requiresUserInput(event);
+}
+__name(raisedInterrupt, "raisedInterrupt");
+function reconstructNodeStates(events, parentPath) {
+  if (parentPath) {
+    return reconstruct(
+      events,
+      (event) => {
+        var _a;
+        return ((_a = event.nodeInfo) == null ? void 0 : _a.path) ? directChildName(event.nodeInfo.path, parentPath) : void 0;
+      }
+    );
+  }
+  return reconstruct(
+    events,
+    (event) => {
+      var _a;
+      return ((_a = event.nodeInfo) == null ? void 0 : _a.path) ? nodeNameFromPath(event.nodeInfo.path) : event.author;
+    }
+  );
+}
+__name(reconstructNodeStates, "reconstructNodeStates");
+function reconstructNodeStatesByPath(events) {
+  return reconstruct(events, (event) => {
+    var _a, _b;
+    return (_b = (_a = event.nodeInfo) == null ? void 0 : _a.path) != null ? _b : event.author;
+  });
+}
+__name(reconstructNodeStatesByPath, "reconstructNodeStatesByPath");
+function resolvedInterruptResponses(events) {
+  var _a, _b;
+  const responseSchemas = responseSchemasByInterruptId(events);
+  const newestUserTurn = lastUserEvent(events);
+  const raised = /* @__PURE__ */ new Set();
+  const open = /* @__PURE__ */ new Set();
+  const resolved = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.author === "user" && ((_a = event.content) == null ? void 0 : _a.parts)) {
+      for (const part of event.content.parts) {
+        const fr = part.functionResponse;
+        if (!(fr == null ? void 0 : fr.id)) {
+          continue;
+        }
+        if (!open.has(fr.id)) {
+          if (fr.name === REQUEST_INPUT_FUNCTION_CALL_NAME && event === newestUserTurn) {
+            throw new Error(
+              raised.has(fr.id) ? alreadyAnsweredMessage(fr.id, open) : unroutableReplyMessage(fr.id, open)
+            );
+          }
+          continue;
+        }
+        const schema = responseSchemas.get(fr.id);
+        const response = unwrapResponse(fr.response, schema);
+        const mismatch = interruptResponseMismatch(fr.id, response, schema);
+        if (mismatch) {
+          if (event === newestUserTurn) {
+            throw new Error(mismatch);
+          }
+          continue;
+        }
+        open.delete(fr.id);
+        resolved.set(fr.id, response);
+      }
+      continue;
+    }
+    for (const id of (_b = event.longRunningToolIds) != null ? _b : []) {
+      raised.add(id);
+      open.add(id);
+    }
+  }
+  return resolved;
+}
+__name(resolvedInterruptResponses, "resolvedInterruptResponses");
+function waitingList(open) {
+  return open.size ? `Still waiting: ${[...open].map((id) => `'${id}'`).join(", ")}.` : "This run has no interrupt waiting for an answer.";
+}
+__name(waitingList, "waitingList");
+function unroutableReplyMessage(interruptId, open) {
+  return `The reply carries interrupt id '${interruptId}', which does not match any interrupt this run raised. ${waitingList(open)} A reply must use the id from the 'adk_request_input' function call it answers. Nothing was resolved, so any waiting interrupt can still be answered.`;
+}
+__name(unroutableReplyMessage, "unroutableReplyMessage");
+function alreadyAnsweredMessage(interruptId, open) {
+  return `Interrupt '${interruptId}' has already been answered, so this reply resolves nothing. Sending it again does not change the earlier answer, and it would otherwise be served as a new message, restarting the node that asked. ${waitingList(open)}`;
+}
+__name(alreadyAnsweredMessage, "alreadyAnsweredMessage");
+function reconstructNodeRuns(events, parentPath) {
+  return reconstructRuns(events, keyFn(parentPath));
+}
+__name(reconstructNodeRuns, "reconstructNodeRuns");
+function keyFn(parentPath) {
+  if (parentPath) {
+    return (event) => {
+      var _a;
+      return ((_a = event.nodeInfo) == null ? void 0 : _a.path) ? directChildName(event.nodeInfo.path, parentPath) : void 0;
+    };
+  }
+  return (event) => {
+    var _a;
+    return ((_a = event.nodeInfo) == null ? void 0 : _a.path) ? nodeNameFromPath(event.nodeInfo.path) : event.author;
+  };
+}
+__name(keyFn, "keyFn");
+function isRunClosed(node) {
+  return node.output !== void 0 || node.route !== void 0 || node.interruptIds.size > 0;
+}
+__name(isRunClosed, "isRunClosed");
+function reconstruct(events, keyFor) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const [key, runs] of reconstructRuns(events, keyFor)) {
+    const node = {
+      interruptIds: /* @__PURE__ */ new Set(),
+      resolvedResponses: /* @__PURE__ */ new Map()
+    };
+    for (const run of runs) {
+      if (run.output !== void 0) {
+        node.output = run.output;
+        node.branch = run.branch;
+      }
+      if (run.route !== void 0) node.route = run.route;
+      if (run.input !== void 0) node.input = run.input;
+      for (const id of run.interruptIds) node.interruptIds.add(id);
+      for (const [id, value] of run.resolvedResponses) {
+        node.resolvedResponses.set(id, value);
+      }
+    }
+    merged.set(key, node);
+  }
+  return merged;
+}
+__name(reconstruct, "reconstruct");
+function reconstructRuns(events, keyFor) {
+  var _a, _b, _c;
+  const nodes = /* @__PURE__ */ new Map();
+  const interruptOwner = /* @__PURE__ */ new Map();
+  const resolved = resolvedInterruptResponses(events);
+  const currentRun = /* @__PURE__ */ __name((name) => {
+    let runs = nodes.get(name);
+    if (!runs) {
+      runs = [];
+      nodes.set(name, runs);
+    }
+    const open = runs[runs.length - 1];
+    if (open && !isRunClosed(open)) {
+      return open;
+    }
+    const run = {
+      interruptIds: /* @__PURE__ */ new Set(),
+      resolvedResponses: /* @__PURE__ */ new Map()
+    };
+    runs.push(run);
+    return run;
+  }, "currentRun");
+  for (const event of events) {
+    if (event.author === "user" && ((_a = event.content) == null ? void 0 : _a.parts)) {
+      for (const part of event.content.parts) {
+        const fr = part.functionResponse;
+        if ((fr == null ? void 0 : fr.id) && interruptOwner.has(fr.id) && resolved.has(fr.id)) {
+          interruptOwner.get(fr.id).resolvedResponses.set(fr.id, resolved.get(fr.id));
+        }
+      }
+      continue;
+    }
+    const key = keyFor(event);
+    if (!key) {
+      continue;
+    }
+    const node = currentRun(key);
+    if (event.output !== void 0) {
+      node.output = event.output;
+      node.branch = event.branch;
+    }
+    if (event.route !== void 0) {
+      node.route = event.route;
+    }
+    for (const id of (_b = event.longRunningToolIds) != null ? _b : []) {
+      node.interruptIds.add(id);
+      interruptOwner.set(id, node);
+    }
+    const agentState = (_c = event.actions) == null ? void 0 : _c.agentState;
+    if (isRecord(agentState) && "input" in agentState) {
+      node.input = agentState.input;
+    }
+  }
+  return nodes;
+}
+__name(reconstructRuns, "reconstructRuns");
+function lastUserEvent(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    if (events[i].author === "user") {
+      return events[i];
+    }
+  }
+  return void 0;
+}
+__name(lastUserEvent, "lastUserEvent");
+function isFastForwardable(node) {
+  if (node.output === void 0 && node.route === void 0) {
+    return false;
+  }
+  for (const id of node.interruptIds) {
+    if (!node.resolvedResponses.has(id)) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(isFastForwardable, "isFastForwardable");
+function makeFastForwardResult(parent, prior) {
+  var _a;
+  return {
+    output: prior.output,
+    route: prior.route,
+    branch: (_a = prior.branch) != null ? _a : parent.branch,
+    interruptIds: []
+  };
+}
+__name(makeFastForwardResult, "makeFastForwardResult");
+function nodeNameFromPath(path) {
+  var _a;
+  const leaf = (_a = path.split(/[./]/).pop()) != null ? _a : path;
+  return leaf.split("@")[0];
+}
+__name(nodeNameFromPath, "nodeNameFromPath");
+function directChildName(path, parentPath) {
+  const prefix = `${parentPath}.`;
+  if (!path.startsWith(prefix)) {
+    return void 0;
+  }
+  const rest = path.slice(prefix.length);
+  if (rest.includes(".")) {
+    return void 0;
+  }
+  return rest.split("@")[0];
+}
+__name(directChildName, "directChildName");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function unwrapResponse(response, responseSchema) {
+  if (response && typeof response === "object" && !Array.isArray(response) && Object.keys(response).length === 1 && RESULT_KEY in response) {
+    const value = response[RESULT_KEY];
+    if (typeof value !== "string" || acceptsString(responseSchema)) {
+      return value;
+    }
+    return parseJsonIfPossible(value);
+  }
+  return response;
+}
+__name(unwrapResponse, "unwrapResponse");
+function acceptsString(jsonSchema) {
+  if (!isRecord(jsonSchema)) {
+    return false;
+  }
+  const type = jsonSchema["type"];
+  if (type === "string") {
+    return true;
+  }
+  if (Array.isArray(type) && type.includes("string")) {
+    return true;
+  }
+  for (const key of ["anyOf", "oneOf"]) {
+    const branches = jsonSchema[key];
+    if (Array.isArray(branches) && branches.some(acceptsString)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(acceptsString, "acceptsString");
+function parseJsonIfPossible(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+__name(parseJsonIfPossible, "parseJsonIfPossible");
+export {
+  eventsForCurrentRun,
+  isFastForwardable,
+  makeFastForwardResult,
+  nodeNameFromPath,
+  reconstructNodeRuns,
+  reconstructNodeStates,
+  reconstructNodeStatesByPath,
+  resolvedInterruptResponses,
+  unwrapResponse
+};

package/dist/esm/workflow/utils/retry_utils.js

@@ -0,0 +1,82 @@
+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 DEFAULT_MAX_ATTEMPTS = 5;
+const DEFAULT_INITIAL_DELAY_SECONDS = 1;
+const DEFAULT_MAX_DELAY_SECONDS = 60;
+const DEFAULT_BACKOFF_FACTOR = 2;
+const DEFAULT_JITTER = 1;
+function errorNames(error) {
+  var _a;
+  if (error instanceof Error) {
+    const names = [(_a = error.constructor) == null ? void 0 : _a.name, error.name].filter(
+      (name) => !!name
+    );
+    return [...new Set(names)];
+  }
+  if (typeof error === "object" && error !== null) {
+    return [error.constructor.name];
+  }
+  return [typeof error];
+}
+__name(errorNames, "errorNames");
+function errorName(error) {
+  const [className, assigned] = errorNames(error);
+  if (className === "Error" && assigned) {
+    return assigned;
+  }
+  return className;
+}
+__name(errorName, "errorName");
+function shouldRetryNode({
+  error,
+  retryConfig,
+  nodeState
+}) {
+  var _a;
+  const attemptCount = nodeState.attemptCount;
+  const maxAttempts = (_a = retryConfig.maxAttempts) != null ? _a : DEFAULT_MAX_ATTEMPTS;
+  if (attemptCount >= maxAttempts) {
+    return false;
+  }
+  const exceptions = retryConfig.exceptions;
+  if (exceptions !== void 0 && !errorNames(error).some((name) => exceptions.includes(name))) {
+    return false;
+  }
+  return true;
+}
+__name(shouldRetryNode, "shouldRetryNode");
+function getRetryDelaySeconds({
+  retryConfig,
+  nodeState,
+  randomFn = Math.random
+}) {
+  var _a, _b, _c, _d;
+  const initialDelay = (_a = retryConfig.initialDelay) != null ? _a : DEFAULT_INITIAL_DELAY_SECONDS;
+  const maxDelay = (_b = retryConfig.maxDelay) != null ? _b : DEFAULT_MAX_DELAY_SECONDS;
+  const backoffFactor = (_c = retryConfig.backoffFactor) != null ? _c : DEFAULT_BACKOFF_FACTOR;
+  const jitter = (_d = retryConfig.jitter) != null ? _d : DEFAULT_JITTER;
+  const attemptCount = nodeState.attemptCount || 1;
+  const attemptForCalc = Math.max(0, attemptCount - 1);
+  let delay = initialDelay * Math.pow(backoffFactor, attemptForCalc);
+  if (jitter > 0) {
+    delay = Math.min(delay, maxDelay / (1 + jitter));
+    const span = jitter * delay;
+    const randomOffset = -span + randomFn() * (2 * span);
+    delay = Math.max(0, delay + randomOffset);
+  }
+  return Math.min(delay, maxDelay);
+}
+__name(getRetryDelaySeconds, "getRetryDelaySeconds");
+export {
+  errorName,
+  errorNames,
+  getRetryDelaySeconds,
+  shouldRetryNode
+};

package/dist/esm/workflow/utils/workflow_graph_utils.js

@@ -0,0 +1,115 @@
+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 { isBaseNode, START } from "../base_node.js";
+import { NODE_BUILDERS, PARALLEL_WORKER_FACTORY } from "../node_builders.js";
+import { prepareRetryConfig } from "../retry_config.js";
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+__name(isPlainObject, "isPlainObject");
+function isNodeLike(value) {
+  return value === "START" || isBaseNode(value) || NODE_BUILDERS.some((builder) => builder.match(value));
+}
+__name(isNodeLike, "isNodeLike");
+function buildNode(nodeLike, options = {}) {
+  if (options.maxParallelWorkers !== void 0 && !options.parallelWorker) {
+    throw new Error(
+      "maxParallelWorkers can only be set when parallelWorker is true."
+    );
+  }
+  const built = buildInnerNode(nodeLike, options);
+  if (options.parallelWorker) {
+    if (nodeLike === "START") {
+      throw new Error("ParallelWorker cannot wrap a START node.");
+    }
+    if (!PARALLEL_WORKER_FACTORY) {
+      throw new Error(
+        "parallelWorker was requested but no ParallelWorker is available; the parallel worker node module is not part of this build."
+      );
+    }
+    return PARALLEL_WORKER_FACTORY(built, {
+      maxParallelWorkers: options.maxParallelWorkers
+    });
+  }
+  return built;
+}
+__name(buildNode, "buildNode");
+function buildInnerNode(nodeLike, options) {
+  if (nodeLike === "START") {
+    return START;
+  }
+  if (isBaseNode(nodeLike)) {
+    return cloneWithOverrides(nodeLike, options);
+  }
+  for (const builder of NODE_BUILDERS) {
+    if (builder.match(nodeLike)) {
+      return builder.build(nodeLike, options);
+    }
+  }
+  throw new Error(
+    `build_node: unsupported node-like value of type ${typeof nodeLike}. Import the node module that handles it (e.g. via the workflow barrel).`
+  );
+}
+__name(buildInnerNode, "buildInnerNode");
+const OVERRIDABLE_KEYS = [
+  "name",
+  "description",
+  "rerunOnResume",
+  "retryConfig",
+  "timeout",
+  "inputSchema",
+  "outputSchema",
+  "stateSchema",
+  "isolationScope"
+];
+const NODE_DECLARED_KEYS = ["authConfig"];
+function cloneWithOverrides(node, options) {
+  const overrides = {};
+  for (const key of OVERRIDABLE_KEYS) {
+    if (options[key] !== void 0) {
+      overrides[key] = options[key];
+    }
+  }
+  for (const key of NODE_DECLARED_KEYS) {
+    if (options[key] !== void 0 && key in node) {
+      overrides[key] = options[key];
+    }
+  }
+  if (Object.keys(overrides).length === 0) {
+    return node;
+  }
+  if (typeof overrides["name"] === "string") {
+    const name = overrides["name"].trim();
+    if (!name) {
+      throw new Error("Node name must be a non-empty string.");
+    }
+    overrides["name"] = name;
+  }
+  const clone = Object.create(
+    Object.getPrototypeOf(node)
+  );
+  Object.assign(clone, node, overrides);
+  if ("retryConfig" in overrides) {
+    Object.assign(clone, {
+      preparedRetryConfig: options.retryConfig ? prepareRetryConfig(options.retryConfig) : void 0
+    });
+  }
+  return clone;
+}
+__name(cloneWithOverrides, "cloneWithOverrides");
+export {
+  buildNode,
+  isNodeLike,
+  isPlainObject
+};