@google/adk 1.5.0 → 2.0.0

package/dist/esm/workflow/nodes/function_node.js

@@ -0,0 +1,172 @@
+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 { createEvent, isEvent } from "../../events/event.js";
+import { carryDeltaStamp } from "../../sessions/state_write_order.js";
+import { BaseNode, isContent, toContent } from "../base_node.js";
+import {
+  createAuthRequestEvent,
+  hasAuthCredential,
+  processAuthResume
+} from "../utils/hitl_utils.js";
+const _FunctionNode = class _FunctionNode extends BaseNode {
+  constructor(name, handler, config = {}) {
+    if (typeof handler !== "function") {
+      throw new TypeError("FunctionNode handler must be a function.");
+    }
+    super({ ...config, name });
+    /** Per-run shadow of the state entries already attached to an emitted event. */
+    this.attachedStateByCtx = /* @__PURE__ */ new WeakMap();
+    this.handler = handler;
+    this.authConfig = config.authConfig;
+  }
+  async *runImpl(ctx, input) {
+    if (this.authConfig) {
+      const authRequest = await this.runAuthGate(ctx);
+      if (authRequest) {
+        yield authRequest;
+        return;
+      }
+    }
+    const result = this.handler(ctx, input);
+    if (isAsyncIterable(result)) {
+      for await (const item of result) {
+        yield item;
+      }
+    } else if (isSyncGenerator(result)) {
+      for (const item of result) {
+        yield item;
+      }
+    } else {
+      yield await result;
+    }
+    yield void 0;
+  }
+  /**
+   * Ensures a credential for `authConfig` is available. Returns an
+   * `adk_request_credential` interrupt event if the credential must be
+   * requested from the user, or `undefined` if the node may proceed.
+   *
+   * On resume, a credential provided via `ctx.resumeInputs[credentialKey]` is
+   * stored into state before re-checking.
+   */
+  async runAuthGate(ctx) {
+    const authConfig = this.authConfig;
+    if (hasAuthCredential(authConfig, ctx.state)) {
+      return void 0;
+    }
+    const resumeResponse = ctx.resumeInputs[authConfig.credentialKey];
+    if (resumeResponse !== void 0) {
+      await processAuthResume({
+        responseData: resumeResponse,
+        authConfig,
+        state: ctx.state
+      });
+      if (hasAuthCredential(authConfig, ctx.state)) {
+        return void 0;
+      }
+    }
+    return createAuthRequestEvent(authConfig, authConfig.credentialKey);
+  }
+  /**
+   * Returns the state-delta entries written since the last event was emitted
+   * for this run (new keys or changed values). A multi-event handler would
+   * otherwise re-emit the whole growing delta on every event.
+   *
+   * `ctx.actions.stateDelta` can't be drained — `NodeContext` builds its
+   * `State` over it — so we track what has already been attached in a shadow
+   * map keyed by the run's context (GC'd with the context).
+   */
+  pendingStateDelta(ctx) {
+    let shadow = this.attachedStateByCtx.get(ctx);
+    if (!shadow) {
+      shadow = /* @__PURE__ */ new Map();
+      this.attachedStateByCtx.set(ctx, shadow);
+    }
+    const delta = {};
+    for (const [key, value] of Object.entries(ctx.actions.stateDelta)) {
+      if (!shadow.has(key) || shadow.get(key) !== value) {
+        delta[key] = value;
+        shadow.set(key, value);
+        carryDeltaStamp(ctx.actions.stateDelta, delta, key);
+      }
+    }
+    return Object.keys(delta).length > 0 ? delta : void 0;
+  }
+  /**
+   * Writes an emitted event's state delta into the node's own state view, and
+   * records it as already attached so {@link pendingStateDelta} does not emit a
+   * second event carrying the same keys.
+   */
+  applyEmittedState(ctx, delta) {
+    if (!delta || Object.keys(delta).length === 0) {
+      return;
+    }
+    ctx.state.update(delta);
+    const shadow = this.attachedStateByCtx.get(ctx);
+    if (shadow) {
+      for (const [key, value] of Object.entries(delta)) {
+        shadow.set(key, value);
+      }
+    }
+  }
+  toEvent(ctx, data) {
+    const stateDelta = this.pendingStateDelta(ctx);
+    if (data === null || data === void 0) {
+      return stateDelta ? createEvent({
+        author: this.name,
+        invocationId: ctx.invocationId,
+        branch: ctx.branch,
+        actions: { stateDelta }
+      }) : null;
+    }
+    if (isEvent(data)) {
+      const event = data;
+      if (event.output !== void 0) {
+        event.output = this.validateOutput(event.output);
+      }
+      if (stateDelta) {
+        event.actions.stateDelta = { ...stateDelta, ...event.actions.stateDelta };
+      }
+      this.applyEmittedState(ctx, event.actions.stateDelta);
+      return event;
+    }
+    if (isContent(data)) {
+      return createEvent({
+        author: this.name,
+        invocationId: ctx.invocationId,
+        branch: ctx.branch,
+        content: data,
+        actions: stateDelta ? { stateDelta } : void 0
+      });
+    }
+    const output = this.validateOutput(data);
+    return createEvent({
+      author: this.name,
+      invocationId: ctx.invocationId,
+      branch: ctx.branch,
+      content: toContent(output),
+      output,
+      actions: stateDelta ? { stateDelta } : void 0
+    });
+  }
+};
+__name(_FunctionNode, "FunctionNode");
+let FunctionNode = _FunctionNode;
+function isAsyncIterable(value) {
+  return value != null && typeof value[Symbol.asyncIterator] === "function";
+}
+__name(isAsyncIterable, "isAsyncIterable");
+function isSyncGenerator(value) {
+  return value != null && typeof value[Symbol.iterator] === "function" && typeof value.next === "function";
+}
+__name(isSyncGenerator, "isSyncGenerator");
+export {
+  FunctionNode
+};

package/dist/esm/workflow/nodes/join_node.js

@@ -0,0 +1,29 @@
+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 { createEvent } from "../../events/event.js";
+import { BaseNode } from "../base_node.js";
+const _JoinNode = class _JoinNode extends BaseNode {
+  get requiresAllPredecessors() {
+    return true;
+  }
+  async *runImpl(ctx, input) {
+    yield createEvent({
+      author: this.name,
+      invocationId: ctx.invocationId,
+      branch: ctx.branch,
+      output: input
+    });
+  }
+};
+__name(_JoinNode, "JoinNode");
+let JoinNode = _JoinNode;
+export {
+  JoinNode
+};

package/dist/esm/workflow/nodes/node_tool.js

@@ -0,0 +1,131 @@
+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, _b;
+import { Type } from "@google/genai";
+import { BaseTool } from "../../tools/base_tool.js";
+import {
+  isZodObject,
+  zodObjectToSchema
+} from "../../utils/simple_zod_to_json.js";
+import { NodeContext } from "../node_context.js";
+import { executeChildNode } from "../node_runner.js";
+const NODE_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.nodeTool");
+const MAX_NODE_TOOL_DEPTH = 8;
+const _NodeTool = class _NodeTool extends (_b = BaseTool, _a = NODE_TOOL_SIGNATURE_SYMBOL, _b) {
+  constructor(node, name, description) {
+    if (!node.inputSchema) {
+      throw new Error(
+        `Node '${node.name}' does not have an inputSchema defined. NodeTool requires an explicit input schema on the wrapped node.`
+      );
+    }
+    super({
+      name: name != null ? name : node.name,
+      description: description || node.description || `Executes the node: ${node.name}`,
+      isLongRunning: true
+    });
+    /** Brand identifying this object as a {@link NodeTool} (see `isNodeTool`). */
+    this[_a] = true;
+    this.node = node;
+  }
+  _getDeclaration() {
+    const schema = this.node.inputSchema;
+    let parameters;
+    if (schema && isZodObject(schema)) {
+      parameters = zodObjectToSchema(schema);
+    } else {
+      parameters = {
+        type: Type.OBJECT,
+        properties: { request: { type: Type.STRING } },
+        required: ["request"]
+      };
+    }
+    return { name: this.name, description: this.description, parameters };
+  }
+  /** Whether the node's input schema is a (Zod) object rather than a scalar. */
+  get inputIsObject() {
+    return isZodObject(this.node.inputSchema);
+  }
+  async runAsync({
+    args,
+    toolContext
+  }) {
+    const nodeInput = this.inputIsObject ? args : args["request"];
+    const child = await this.runNode(toolContext, nodeInput);
+    if (child.interruptIds.length > 0) {
+      return void 0;
+    }
+    return child.output === void 0 ? { result: null } : child.output;
+  }
+  /**
+   * Runs the wrapped node with a {@link NodeContext} bridged from the agent's
+   * tool context. Node events are streamed into the invocation's event queue so
+   * intermediate/interrupt events surface to the agent (and a paused node can be
+   * resumed). Requires being invoked from an `LlmAgent` tool-call step, which is
+   * what provides that queue and the function-call id.
+   */
+  async runNode(toolContext, nodeInput) {
+    const ic = toolContext.invocationContext;
+    const channel = ic.eventQueue;
+    if (!channel) {
+      throw new Error(
+        `NodeTool '${this.name}' requires an invocation event queue; it must be invoked from an LlmAgent tool-call step.`
+      );
+    }
+    const runId = toolContext.functionCallId;
+    if (!runId) {
+      throw new Error(
+        `NodeTool '${this.name}' requires a function-call id; it must be invoked from an LlmAgent tool-call step.`
+      );
+    }
+    if (ic.nodeToolDepth >= MAX_NODE_TOOL_DEPTH) {
+      throw new Error(
+        `NodeTool '${this.name}': node-tool nesting exceeded ${MAX_NODE_TOOL_DEPTH} (possible node -> tool -> node recursion).`
+      );
+    }
+    const childIc = ic.clone({ nodeToolDepth: ic.nodeToolDepth + 1 });
+    const nodeCtx = new NodeContext({
+      invocationContext: childIc,
+      channel,
+      // Empty so executeChildNode's path is a single segment (the node name),
+      // not the node name doubled.
+      nodePath: "",
+      runId,
+      resumeInputs: collectResumeInputs(toolContext)
+    });
+    const base = childIc.branch;
+    const segment = `${this.name}@${runId}`;
+    const overrideBranch = base ? `${base}.${segment}` : segment;
+    return executeChildNode({
+      parent: nodeCtx,
+      node: this.node,
+      input: nodeInput,
+      options: { runId, overrideBranch }
+    });
+  }
+};
+__name(_NodeTool, "NodeTool");
+let NodeTool = _NodeTool;
+function isNodeTool(value) {
+  return typeof value === "object" && value !== null && NODE_TOOL_SIGNATURE_SYMBOL in value && value[NODE_TOOL_SIGNATURE_SYMBOL] === true;
+}
+__name(isNodeTool, "isNodeTool");
+function collectResumeInputs(toolContext) {
+  var _a2;
+  const payload = (_a2 = toolContext.toolConfirmation) == null ? void 0 : _a2.payload;
+  if (payload && typeof payload === "object") {
+    return payload;
+  }
+  return {};
+}
+__name(collectResumeInputs, "collectResumeInputs");
+export {
+  NodeTool,
+  isNodeTool
+};

package/dist/esm/workflow/nodes/parallel_worker.js

@@ -0,0 +1,102 @@
+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 { BaseNode } from "../base_node.js";
+import { isNodeInterruptedError } from "../errors.js";
+import { buildNode } from "../utils/workflow_graph_utils.js";
+const DEFAULT_MAX_PARALLEL_WORKERS = 8;
+const _ParallelWorker = class _ParallelWorker extends BaseNode {
+  constructor(inner, config = {}) {
+    const built = buildNode(inner);
+    super({ name: built.name, rerunOnResume: true });
+    if (config.maxParallelWorkers !== void 0 && config.maxParallelWorkers < 1) {
+      throw new Error("maxParallelWorkers must be greater than or equal to 1.");
+    }
+    this.inner = built;
+    this.maxParallelWorkers = config.maxParallelWorkers;
+  }
+  async *runImpl(ctx, input) {
+    var _a;
+    const items = Array.isArray(input) ? input : [input];
+    if (items.length === 0) {
+      yield [];
+      return;
+    }
+    const results = new Array(items.length);
+    const poolSize = Math.min(
+      (_a = this.maxParallelWorkers) != null ? _a : DEFAULT_MAX_PARALLEL_WORKERS,
+      items.length
+    );
+    let nextIndex = 0;
+    let failed = false;
+    let firstError;
+    let interrupted = false;
+    const interruptIds = [];
+    const isAborted = /* @__PURE__ */ __name(() => {
+      var _a2, _b;
+      return ((_a2 = ctx.abortSignal) == null ? void 0 : _a2.aborted) === true || ((_b = ctx.invocationContext.abortSignal) == null ? void 0 : _b.aborted) === true;
+    }, "isAborted");
+    const worker = /* @__PURE__ */ __name(async () => {
+      while (!failed && !interrupted && !isAborted()) {
+        const i = nextIndex++;
+        if (i >= items.length) {
+          break;
+        }
+        try {
+          const child = await ctx.runNode(this.inner, items[i], {
+            useSubBranch: true,
+            runId: String(i),
+            overrideNodePath: `${ctx.nodePath}.${this.inner.name}@${i}`
+          });
+          if (child.interruptIds.length > 0) {
+            interrupted = true;
+            for (const id of child.interruptIds) {
+              if (!interruptIds.includes(id)) {
+                interruptIds.push(id);
+              }
+            }
+            break;
+          }
+          results[i] = child.output;
+        } catch (err) {
+          if (isNodeInterruptedError(err)) {
+            interrupted = true;
+            break;
+          }
+          if (!failed) {
+            failed = true;
+            firstError = err;
+          }
+          break;
+        }
+      }
+    }, "worker");
+    await Promise.all(Array.from({ length: poolSize }, () => worker()));
+    if (failed) {
+      throw firstError;
+    }
+    if (interrupted) {
+      for (const id of interruptIds) {
+        if (!ctx.interruptIds.includes(id)) {
+          ctx.interruptIds.push(id);
+        }
+      }
+      return;
+    }
+    if (isAborted()) {
+      return;
+    }
+    yield results;
+  }
+};
+__name(_ParallelWorker, "ParallelWorker");
+let ParallelWorker = _ParallelWorker;
+export {
+  ParallelWorker
+};

package/dist/esm/workflow/nodes/tool_node.js

@@ -0,0 +1,90 @@
+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 { handleFunctionCallList } from "../../agents/functions.js";
+import { getFunctionResponses } from "../../events/event.js";
+import { BaseNode, isContent } from "../base_node.js";
+const _ToolNode = class _ToolNode extends BaseNode {
+  constructor(tool, config = {}) {
+    var _a;
+    super({ ...config, name: (_a = config.name) != null ? _a : tool.name });
+    if (tool.isLongRunning) {
+      throw new Error(
+        `ToolNode does not support long-running tools yet (tool '${tool.name}').`
+      );
+    }
+    this.tool = tool;
+  }
+  async *runImpl(ctx, input) {
+    const args = this.validateInput(coerceToolArgs(input));
+    const functionCall = {
+      name: this.tool.name,
+      args,
+      id: `${ctx.nodePath}:${ctx.runId}`
+    };
+    const responseEvent = await handleFunctionCallList({
+      invocationContext: ctx.invocationContext,
+      functionCalls: [functionCall],
+      toolsDict: { [this.tool.name]: this.tool },
+      // Plugin callbacks still run via invocationContext.pluginManager; there is
+      // no agent-level tool-callback list on a workflow node.
+      beforeToolCallbacks: [],
+      afterToolCallbacks: []
+    });
+    if (!responseEvent) {
+      return;
+    }
+    responseEvent.author = this.name;
+    const responses = getFunctionResponses(responseEvent);
+    if (responses.length > 0) {
+      responseEvent.output = responses[0].response;
+    }
+    yield responseEvent;
+  }
+};
+__name(_ToolNode, "ToolNode");
+let ToolNode = _ToolNode;
+function coerceToolArgs(input) {
+  let args = input;
+  if (isContent(args)) {
+    args = extractText(args);
+  }
+  if (typeof args === "string") {
+    const trimmed = args.trim();
+    if (!trimmed) {
+      args = null;
+    } else {
+      try {
+        args = JSON.parse(trimmed);
+      } catch {
+      }
+    }
+  }
+  if (args === null || args === void 0) {
+    return {};
+  }
+  if (typeof args !== "object" || Array.isArray(args)) {
+    throw new TypeError(
+      `The input to ToolNode must be an object of tool arguments or null, but got ${typeof args}.`
+    );
+  }
+  return args;
+}
+__name(coerceToolArgs, "coerceToolArgs");
+function extractText(content) {
+  var _a;
+  return ((_a = content.parts) != null ? _a : []).map((p) => {
+    var _a2;
+    return (_a2 = p.text) != null ? _a2 : "";
+  }).join("");
+}
+__name(extractText, "extractText");
+export {
+  ToolNode
+};

package/dist/esm/workflow/request_input.js

@@ -0,0 +1,36 @@
+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 { randomUUID } from "../utils/env_aware_utils.js";
+const REQUEST_INPUT_SIGNATURE_SYMBOL = Symbol.for(
+  "google.adk.workflow.requestInput"
+);
+_a = REQUEST_INPUT_SIGNATURE_SYMBOL;
+const _RequestInput = class _RequestInput {
+  constructor(params = {}) {
+    /** Brand identifying this object as a {@link RequestInput} (see {@link isRequestInput}). */
+    this[_a] = true;
+    var _a2;
+    this.interruptId = (_a2 = params.interruptId) != null ? _a2 : randomUUID();
+    this.payload = params.payload;
+    this.message = params.message;
+    this.responseSchema = params.responseSchema;
+  }
+};
+__name(_RequestInput, "RequestInput");
+let RequestInput = _RequestInput;
+function isRequestInput(value) {
+  return typeof value === "object" && value !== null && REQUEST_INPUT_SIGNATURE_SYMBOL in value && value[REQUEST_INPUT_SIGNATURE_SYMBOL] === true;
+}
+__name(isRequestInput, "isRequestInput");
+export {
+  RequestInput,
+  isRequestInput
+};

package/dist/esm/workflow/retry_config.js

@@ -0,0 +1,43 @@
+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
+ */
+function normalizeRetryExceptions(exceptions) {
+  if (exceptions === void 0 || exceptions === null) {
+    return void 0;
+  }
+  return exceptions.map((item) => {
+    if (typeof item === "string") {
+      return item;
+    }
+    if (typeof item === "function" && item.name) {
+      return item.name;
+    }
+    throw new Error(
+      `exceptions must contain error class names (string) or error classes, got: ${String(
+        item
+      )}`
+    );
+  });
+}
+__name(normalizeRetryExceptions, "normalizeRetryExceptions");
+function prepareRetryConfig(config) {
+  return {
+    maxAttempts: config.maxAttempts,
+    initialDelay: config.initialDelay,
+    maxDelay: config.maxDelay,
+    backoffFactor: config.backoffFactor,
+    jitter: config.jitter,
+    exceptions: normalizeRetryExceptions(config.exceptions)
+  };
+}
+__name(prepareRetryConfig, "prepareRetryConfig");
+export {
+  normalizeRetryExceptions,
+  prepareRetryConfig
+};