@google/adk 1.6.0 → 2.1.0

package/dist/cjs/workflow/request_input.js

@@ -0,0 +1,64 @@
+/**
+  * @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 request_input_exports = {};
+__export(request_input_exports, {
+  RequestInput: () => RequestInput,
+  isRequestInput: () => isRequestInput
+});
+module.exports = __toCommonJS(request_input_exports);
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+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 : (0, import_env_aware_utils.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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RequestInput,
+  isRequestInput
+});

package/dist/cjs/workflow/retry_config.js

@@ -0,0 +1,71 @@
+/**
+  * @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 retry_config_exports = {};
+__export(retry_config_exports, {
+  normalizeRetryExceptions: () => normalizeRetryExceptions,
+  prepareRetryConfig: () => prepareRetryConfig
+});
+module.exports = __toCommonJS(retry_config_exports);
+/**
+ * @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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizeRetryExceptions,
+  prepareRetryConfig
+});

package/dist/cjs/workflow/run_llm_agent_as_node.js

@@ -0,0 +1,192 @@
+/**
+  * @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 run_llm_agent_as_node_exports = {};
+__export(run_llm_agent_as_node_exports, {
+  runLlmAgentAsNode: () => runLlmAgentAsNode
+});
+module.exports = __toCommonJS(run_llm_agent_as_node_exports);
+var import_event = require("../events/event.js");
+var import_finish_task_tool = require("../tools/finish_task_tool.js");
+var import_logger = require("../utils/logger.js");
+var import_base_node = require("./base_node.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 = (0, import_event.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 = (0, import_event.getFunctionCalls)(event).find(
+      (fc) => fc.name === import_finish_task_tool.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 === "") {
+    import_logger.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 (0, import_event.getFunctionResponses)(event).some((fr) => {
+    var _a;
+    if (fr.name !== import_finish_task_tool.FINISH_TASK_TOOL_NAME) {
+      return false;
+    }
+    const response = (_a = fr.response) != null ? _a : {};
+    return response.result === import_finish_task_tool.FINISH_TASK_SUCCESS_RESULT;
+  });
+}
+__name(isFinishTaskSuccessResponse, "isFinishTaskSuccessResponse");
+function toUserContent(input) {
+  if ((0, import_base_node.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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runLlmAgentAsNode
+});

package/dist/cjs/workflow/run_node_as_invocation.js

@@ -0,0 +1,165 @@
+/**
+  * @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 run_node_as_invocation_exports = {};
+__export(run_node_as_invocation_exports, {
+  asRunnableRoot: () => asRunnableRoot,
+  isRunnableRoot: () => isRunnableRoot,
+  runNodeAsInvocation: () => runNodeAsInvocation
+});
+module.exports = __toCommonJS(run_node_as_invocation_exports);
+var import_base_agent = require("../agents/base_agent.js");
+var import_event = require("../events/event.js");
+var import_async_queue = require("../utils/async_queue.js");
+var import_base_node = require("./base_node.js");
+var import_node_context = require("./node_context.js");
+var import_rehydration_utils = require("./utils/rehydration_utils.js");
+var import_workflow_graph_utils = require("./utils/workflow_graph_utils.js");
+var import_workflow = require("./workflow.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+async function* runNodeAsInvocation(node, ic, options = {}) {
+  var _a;
+  const author = (_a = options.author) != null ? _a : node.name;
+  const channel = new import_async_queue.AsyncQueue();
+  const root = new import_node_context.NodeContext({
+    invocationContext: ic,
+    channel,
+    nodePath: "",
+    runId: author,
+    // Interactive resume: if the node is paused on an interrupt and the user
+    // replies with plain text (not a structured function response), feed that
+    // text to the pending interrupt(s). Structured function responses are still
+    // resolved by the workflow's own rehydration.
+    resumeInputs: resumeInputsFromPlainText(ic)
+  });
+  const input = extractNodeInput(ic.userContent);
+  let interrupted = false;
+  const settle = (async () => {
+    try {
+      const nodeCtx = await root.runNode(node, input, { useAsOutput: true });
+      interrupted = nodeCtx.interruptIds.length > 0;
+      channel.close();
+    } catch (err) {
+      channel.fail(err);
+    }
+  })();
+  let lastOutput;
+  let sawOutput = false;
+  try {
+    for await (const event of channel) {
+      if (event.output !== void 0) {
+        lastOutput = event.output;
+        sawOutput = true;
+      }
+      yield event;
+    }
+    await settle;
+  } finally {
+    channel.close();
+    await settle;
+  }
+  const alreadyLast = sawOutput && Object.is(lastOutput, root.output);
+  if (!interrupted && root.output !== void 0 && !alreadyLast) {
+    yield (0, import_event.createEvent)({
+      author,
+      invocationId: ic.invocationId,
+      branch: ic.branch,
+      content: (0, import_base_node.toContent)(root.output),
+      output: root.output
+    });
+  }
+}
+__name(runNodeAsInvocation, "runNodeAsInvocation");
+function resumeInputsFromPlainText(ic) {
+  var _a, _b, _c, _d;
+  const parts = (_b = (_a = ic.userContent) == null ? void 0 : _a.parts) != null ? _b : [];
+  const isPlainText = parts.length > 0 && parts.every((p) => typeof p.text === "string");
+  if (!isPlainText) {
+    return {};
+  }
+  const text = parts.map((p) => p.text).join("");
+  const pending = /* @__PURE__ */ new Set();
+  const events = (0, import_rehydration_utils.eventsForCurrentRun)((_d = (_c = ic.session) == null ? void 0 : _c.events) != null ? _d : [], ic.invocationId);
+  for (const nodeState of (0, import_rehydration_utils.reconstructNodeStates)(events).values()) {
+    for (const id2 of nodeState.interruptIds) {
+      if (!nodeState.resolvedResponses.has(id2)) {
+        pending.add(id2);
+      }
+    }
+  }
+  if (pending.size !== 1) {
+    return {};
+  }
+  const [id] = pending;
+  return { [id]: text };
+}
+__name(resumeInputsFromPlainText, "resumeInputsFromPlainText");
+function extractNodeInput(content) {
+  var _a;
+  if (!content) {
+    return void 0;
+  }
+  const parts = (_a = content.parts) != null ? _a : [];
+  const textParts = parts.filter((p) => typeof p.text === "string");
+  if (textParts.length > 0) {
+    return textParts.map((p) => p.text).join("");
+  }
+  return content;
+}
+__name(extractNodeInput, "extractNodeInput");
+function isRunnableRoot(value) {
+  return (0, import_base_agent.isBaseAgent)(value) || (0, import_workflow.isWorkflow)(value);
+}
+__name(isRunnableRoot, "isRunnableRoot");
+function asRunnableRoot(root) {
+  var _a, _b;
+  if (isRunnableRoot(root)) {
+    return root;
+  }
+  const value = root;
+  if (!(0, import_workflow_graph_utils.isNodeLike)(value) || value === "START") {
+    const described = value === "START" ? "the 'START' sentinel" : (_b = (_a = value == null ? void 0 : value.constructor) == null ? void 0 : _a.name) != null ? _b : typeof value;
+    throw new TypeError(
+      `Cannot use ${described} as a root: expected a BaseAgent, a Workflow, or a node-like value (a node, a tool, or a function).`
+    );
+  }
+  const built = (0, import_workflow_graph_utils.buildNode)(value);
+  return new import_workflow.Workflow({
+    name: built.name,
+    description: built.description,
+    edges: [["START", built]]
+  });
+}
+__name(asRunnableRoot, "asRunnableRoot");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asRunnableRoot,
+  isRunnableRoot,
+  runNodeAsInvocation
+});

package/dist/cjs/workflow/schedule_dynamic_node.js

@@ -0,0 +1,53 @@
+/**
+  * @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 schedule_dynamic_node_exports = {};
+__export(schedule_dynamic_node_exports, {
+  DynamicNodeState: () => DynamicNodeState
+});
+module.exports = __toCommonJS(schedule_dynamic_node_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const _DynamicNodeState = class _DynamicNodeState {
+  constructor() {
+    /** Dynamic node runs keyed by unique node path (e.g. `wf/node_a@1`). */
+    this.runs = /* @__PURE__ */ new Map();
+    /** Union of unresolved interrupt ids across dynamic child nodes. */
+    this.interruptIds = /* @__PURE__ */ new Set();
+  }
+  /** All in-flight dynamic node tasks. */
+  getDynamicTasks() {
+    return [...this.runs.values()].map((run) => run.task).filter((task) => task !== void 0);
+  }
+};
+__name(_DynamicNodeState, "DynamicNodeState");
+let DynamicNodeState = _DynamicNodeState;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DynamicNodeState
+});

package/dist/cjs/workflow/trigger.js

@@ -0,0 +1,27 @@
+/**
+  * @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 __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 trigger_exports = {};
+module.exports = __toCommonJS(trigger_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */