@google/adk 1.6.0 → 2.1.0

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

@@ -0,0 +1,195 @@
+/**
+  * @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 function_node_exports = {};
+__export(function_node_exports, {
+  FunctionNode: () => FunctionNode
+});
+module.exports = __toCommonJS(function_node_exports);
+var import_event = require("../../events/event.js");
+var import_state_write_order = require("../../sessions/state_write_order.js");
+var import_base_node = require("../base_node.js");
+var import_hitl_utils = require("../utils/hitl_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const _FunctionNode = class _FunctionNode extends import_base_node.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 ((0, import_hitl_utils.hasAuthCredential)(authConfig, ctx.state)) {
+      return void 0;
+    }
+    const resumeResponse = ctx.resumeInputs[authConfig.credentialKey];
+    if (resumeResponse !== void 0) {
+      await (0, import_hitl_utils.processAuthResume)({
+        responseData: resumeResponse,
+        authConfig,
+        state: ctx.state
+      });
+      if ((0, import_hitl_utils.hasAuthCredential)(authConfig, ctx.state)) {
+        return void 0;
+      }
+    }
+    return (0, import_hitl_utils.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);
+        (0, import_state_write_order.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 ? (0, import_event.createEvent)({
+        author: this.name,
+        invocationId: ctx.invocationId,
+        branch: ctx.branch,
+        actions: { stateDelta }
+      }) : null;
+    }
+    if ((0, import_event.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 ((0, import_base_node.isContent)(data)) {
+      return (0, import_event.createEvent)({
+        author: this.name,
+        invocationId: ctx.invocationId,
+        branch: ctx.branch,
+        content: data,
+        actions: stateDelta ? { stateDelta } : void 0
+      });
+    }
+    const output = this.validateOutput(data);
+    return (0, import_event.createEvent)({
+      author: this.name,
+      invocationId: ctx.invocationId,
+      branch: ctx.branch,
+      content: (0, import_base_node.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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FunctionNode
+});

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

@@ -0,0 +1,56 @@
+/**
+  * @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 join_node_exports = {};
+__export(join_node_exports, {
+  JoinNode: () => JoinNode
+});
+module.exports = __toCommonJS(join_node_exports);
+var import_event = require("../../events/event.js");
+var import_base_node = require("../base_node.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const _JoinNode = class _JoinNode extends import_base_node.BaseNode {
+  get requiresAllPredecessors() {
+    return true;
+  }
+  async *runImpl(ctx, input) {
+    yield (0, import_event.createEvent)({
+      author: this.name,
+      invocationId: ctx.invocationId,
+      branch: ctx.branch,
+      output: input
+    });
+  }
+};
+__name(_JoinNode, "JoinNode");
+let JoinNode = _JoinNode;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JoinNode
+});

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

@@ -0,0 +1,147 @@
+/**
+  * @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_tool_exports = {};
+__export(node_tool_exports, {
+  NodeTool: () => NodeTool,
+  isNodeTool: () => isNodeTool
+});
+module.exports = __toCommonJS(node_tool_exports);
+var import_genai = require("@google/genai");
+var import_base_tool = require("../../tools/base_tool.js");
+var import_simple_zod_to_json = require("../../utils/simple_zod_to_json.js");
+var import_node_context = require("../node_context.js");
+var import_node_runner = require("../node_runner.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const NODE_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.workflow.nodeTool");
+const MAX_NODE_TOOL_DEPTH = 8;
+const _NodeTool = class _NodeTool extends (_b = import_base_tool.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 && (0, import_simple_zod_to_json.isZodObject)(schema)) {
+      parameters = (0, import_simple_zod_to_json.zodObjectToSchema)(schema);
+    } else {
+      parameters = {
+        type: import_genai.Type.OBJECT,
+        properties: { request: { type: import_genai.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 (0, import_simple_zod_to_json.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 import_node_context.NodeContext({
+      invocationContext: childIc,
+      channel,
+      // Empty so executeChildNode's path is a single segment (the node name),
+      // not the node name doubled.
+      nodePath: "",
+      runId,
+      resumeInputs: toolContext.resumeInputs
+    });
+    const base = childIc.branch;
+    const segment = `${this.name}@${runId}`;
+    const overrideBranch = base ? `${base}.${segment}` : segment;
+    return (0, import_node_runner.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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NodeTool,
+  isNodeTool
+});

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

@@ -0,0 +1,129 @@
+/**
+  * @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 parallel_worker_exports = {};
+__export(parallel_worker_exports, {
+  ParallelWorker: () => ParallelWorker
+});
+module.exports = __toCommonJS(parallel_worker_exports);
+var import_base_node = require("../base_node.js");
+var import_errors = require("../errors.js");
+var import_workflow_graph_utils = require("../utils/workflow_graph_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const DEFAULT_MAX_PARALLEL_WORKERS = 8;
+const _ParallelWorker = class _ParallelWorker extends import_base_node.BaseNode {
+  constructor(inner, config = {}) {
+    const built = (0, import_workflow_graph_utils.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 ((0, import_errors.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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ParallelWorker
+});

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

@@ -0,0 +1,117 @@
+/**
+  * @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 tool_node_exports = {};
+__export(tool_node_exports, {
+  ToolNode: () => ToolNode
+});
+module.exports = __toCommonJS(tool_node_exports);
+var import_functions = require("../../agents/functions.js");
+var import_event = require("../../events/event.js");
+var import_base_node = require("../base_node.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const _ToolNode = class _ToolNode extends import_base_node.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 (0, import_functions.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 = (0, import_event.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 ((0, import_base_node.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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolNode
+});