@google/adk 1.6.0 → 2.1.0

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

@@ -0,0 +1,122 @@
+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 = /* @__PURE__ */ 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: toolContext.resumeInputs
+    });
+    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");
+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 = /* @__PURE__ */ 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
+};

package/dist/esm/workflow/run_llm_agent_as_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,
+  getFunctionCalls,
+  getFunctionResponses
+} from "../events/event.js";
+import {
+  FINISH_TASK_SUCCESS_RESULT,
+  FINISH_TASK_TOOL_NAME
+} from "../tools/finish_task_tool.js";
+import { logger } from "../utils/logger.js";
+import { isContent } from "./base_node.js";
+async function* runLlmAgentAsNode(agent, ctx, nodeInput) {
+  const isTaskMode = agent.mode === "task";
+  if (!isTaskMode && !agent.includeContentsExplicit) {
+    agent.includeContents = "none";
+  }
+  if (!isTaskMode) {
+    await appendNodeInputAsUserTurn(ctx, nodeInput);
+  }
+  const agentIc = withWorkflowInstructionScope(ctx.getInvocationContext(), {
+    input: nodeInput,
+    outputsByNode: collectPredecessorOutputs(ctx)
+  });
+  if (isTaskMode) {
+    yield* runTaskMode(ctx, agentIc, agent);
+    return;
+  }
+  for await (const event of agent.runAsync(agentIc)) {
+    maybeSetOutput(agent, event);
+    yield event;
+  }
+}
+__name(runLlmAgentAsNode, "runLlmAgentAsNode");
+async function appendNodeInputAsUserTurn(ctx, nodeInput) {
+  if (nodeInput === void 0 || nodeInput === null) {
+    return;
+  }
+  const userEvent = createEvent({
+    author: "user",
+    invocationId: ctx.invocationId,
+    branch: ctx.branch,
+    content: toUserContent(nodeInput)
+  });
+  if (ctx.isolationScope !== void 0) {
+    userEvent.isolationScope = ctx.isolationScope;
+  }
+  const sessionService = ctx.invocationContext.sessionService;
+  if (sessionService) {
+    await sessionService.appendEvent({ session: ctx.session, event: userEvent });
+  } else {
+    ctx.session.events.push(userEvent);
+  }
+}
+__name(appendNodeInputAsUserTurn, "appendNodeInputAsUserTurn");
+async function* runTaskMode(ctx, agentIc, agent) {
+  var _a, _b;
+  const finishTool = agent.finishTaskTool;
+  let pendingArgs;
+  for await (const event of agent.runAsync(agentIc)) {
+    const finishCall = getFunctionCalls(event).find(
+      (fc) => fc.name === FINISH_TASK_TOOL_NAME
+    );
+    if (finishCall) {
+      pendingArgs = { ...(_a = finishCall.args) != null ? _a : {} };
+      yield event;
+      continue;
+    }
+    if (pendingArgs !== void 0 && isFinishTaskSuccessResponse(event)) {
+      const output = finishTool.extractOutput(pendingArgs);
+      event.output = output;
+      event.nodeInfo = { ...(_b = event.nodeInfo) != null ? _b : {}, messageAsOutput: true };
+      if (agent.outputKey && output !== void 0) {
+        ctx.state.set(agent.outputKey, output);
+        event.actions.stateDelta[agent.outputKey] = output;
+      }
+      yield event;
+      return;
+    }
+    yield event;
+  }
+}
+__name(runTaskMode, "runTaskMode");
+function maybeSetOutput(agent, event) {
+  var _a;
+  if (event.partial) {
+    return;
+  }
+  if (hasFunctionCalls(event)) {
+    return;
+  }
+  const content = event.content;
+  if (!content || content.role !== "model" || !content.parts) {
+    return;
+  }
+  const text = content.parts.filter((p) => p.text && !p.thought).map((p) => p.text).join("");
+  let output = text;
+  if (agent.outputSchema && text.trim()) {
+    try {
+      output = JSON.parse(text);
+    } catch {
+      output = text;
+    }
+  }
+  if (output === "") {
+    logger.debug(
+      `Agent '${agent.name}' returned an empty response, so this node's output is the empty string and that is what the next node receives.`
+    );
+  }
+  event.output = output;
+  event.nodeInfo = { ...(_a = event.nodeInfo) != null ? _a : {}, messageAsOutput: true };
+}
+__name(maybeSetOutput, "maybeSetOutput");
+function withWorkflowInstructionScope(ic, scope) {
+  return ic.clone({ workflowInstructionScope: scope });
+}
+__name(withWorkflowInstructionScope, "withWorkflowInstructionScope");
+function collectPredecessorOutputs(ctx) {
+  var _a;
+  const outputs = {};
+  for (const event of ctx.session.events) {
+    if (event.invocationId !== ctx.invocationId || event.output === void 0) {
+      continue;
+    }
+    const path = (_a = event.nodeInfo) == null ? void 0 : _a.path;
+    if (!path) {
+      continue;
+    }
+    const leaf = path.slice(path.lastIndexOf(".") + 1);
+    const name = leaf.includes("@") ? leaf.slice(0, leaf.indexOf("@")) : leaf;
+    outputs[name] = event.output;
+  }
+  return outputs;
+}
+__name(collectPredecessorOutputs, "collectPredecessorOutputs");
+function hasFunctionCalls(event) {
+  var _a, _b;
+  return ((_b = (_a = event.content) == null ? void 0 : _a.parts) != null ? _b : []).some((p) => p.functionCall);
+}
+__name(hasFunctionCalls, "hasFunctionCalls");
+function isFinishTaskSuccessResponse(event) {
+  return getFunctionResponses(event).some((fr) => {
+    var _a;
+    if (fr.name !== FINISH_TASK_TOOL_NAME) {
+      return false;
+    }
+    const response = (_a = fr.response) != null ? _a : {};
+    return response.result === FINISH_TASK_SUCCESS_RESULT;
+  });
+}
+__name(isFinishTaskSuccessResponse, "isFinishTaskSuccessResponse");
+function toUserContent(input) {
+  if (isContent(input)) {
+    return { ...input, role: "user" };
+  }
+  if (typeof input === "string") {
+    return { role: "user", parts: [{ text: input }] };
+  }
+  return { role: "user", parts: [{ text: JSON.stringify(input) }] };
+}
+__name(toUserContent, "toUserContent");
+export {
+  runLlmAgentAsNode
+};