@google/adk 1.5.0 → 2.0.0

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) {
+    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
+};

package/dist/esm/workflow/run_node_as_invocation.js

@@ -0,0 +1,139 @@
+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 { isBaseAgent } from "../agents/base_agent.js";
+import { createEvent } from "../events/event.js";
+import { AsyncQueue } from "../utils/async_queue.js";
+import { toContent } from "./base_node.js";
+import { NodeContext } from "./node_context.js";
+import {
+  eventsForCurrentRun,
+  reconstructNodeStates
+} from "./utils/rehydration_utils.js";
+import { buildNode, isNodeLike } from "./utils/workflow_graph_utils.js";
+import { isWorkflow, Workflow } from "./workflow.js";
+async function* runNodeAsInvocation(node, ic, options = {}) {
+  var _a;
+  const author = (_a = options.author) != null ? _a : node.name;
+  const channel = new AsyncQueue();
+  const root = new 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 createEvent({
+      author,
+      invocationId: ic.invocationId,
+      branch: ic.branch,
+      content: 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 = eventsForCurrentRun((_d = (_c = ic.session) == null ? void 0 : _c.events) != null ? _d : [], ic.invocationId);
+  for (const nodeState of 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 isBaseAgent(value) || isWorkflow(value);
+}
+__name(isRunnableRoot, "isRunnableRoot");
+function asRunnableRoot(root) {
+  var _a, _b;
+  if (isRunnableRoot(root)) {
+    return root;
+  }
+  const value = root;
+  if (!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 = buildNode(value);
+  return new Workflow({
+    name: built.name,
+    description: built.description,
+    edges: [["START", built]]
+  });
+}
+__name(asRunnableRoot, "asRunnableRoot");
+export {
+  asRunnableRoot,
+  isRunnableRoot,
+  runNodeAsInvocation
+};

package/dist/esm/workflow/schedule_dynamic_node.js

@@ -0,0 +1,26 @@
+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 _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;
+export {
+  DynamicNodeState
+};

package/dist/esm/workflow/trigger.js

@@ -0,0 +1,7 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

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

@@ -0,0 +1,188 @@
+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 {
+  Edge,
+  isEdge
+} from "../graph.js";
+import { buildNode, isNodeLike, isPlainObject } from "./workflow_graph_utils.js";
+function normalizeRouteKey(routeKey) {
+  if (/^-?\d+$/.test(routeKey)) {
+    return Number(routeKey);
+  }
+  if (routeKey === "true" || routeKey === "false") {
+    return routeKey === "true";
+  }
+  return routeKey;
+}
+__name(normalizeRouteKey, "normalizeRouteKey");
+function expandRoutingMap(fromElement, routingMap) {
+  const keys = Object.keys(routingMap);
+  if (keys.length === 0) {
+    throw new Error(
+      "Routing map must not be empty. Provide at least one route -> node mapping."
+    );
+  }
+  const expanded = [];
+  for (const routeKey of keys) {
+    const normalizedKey = normalizeRouteKey(routeKey);
+    const target = routingMap[routeKey];
+    if (Array.isArray(target)) {
+      for (const node of target) {
+        if (!isNodeLike(node)) {
+          throw new Error(
+            `Invalid node in fan-out tuple for route ${String(routeKey)}.`
+          );
+        }
+      }
+    } else if (!isNodeLike(target)) {
+      throw new Error(
+        `Invalid routing map value for route ${String(routeKey)}.`
+      );
+    }
+    expanded.push([
+      fromElement,
+      target,
+      normalizedKey
+    ]);
+  }
+  return expanded;
+}
+__name(expandRoutingMap, "expandRoutingMap");
+function nodesFromRoutingMap(routingMap) {
+  const nodes = [];
+  for (const target of Object.values(routingMap)) {
+    if (Array.isArray(target)) {
+      nodes.push(...target);
+    } else {
+      nodes.push(target);
+    }
+  }
+  return nodes;
+}
+__name(nodesFromRoutingMap, "nodesFromRoutingMap");
+function flattenElement(element) {
+  if (isPlainObject(element)) {
+    return nodesFromRoutingMap(element);
+  }
+  if (Array.isArray(element)) {
+    return [...element];
+  }
+  return [element];
+}
+__name(flattenElement, "flattenElement");
+function getOrBuildNode(nodeLike, nodeMap) {
+  if (nodeLike === "START") {
+    return buildNode("START");
+  }
+  if (typeof nodeLike === "object" || typeof nodeLike === "function") {
+    const cached = nodeMap.get(nodeLike);
+    if (cached) {
+      return cached;
+    }
+    const built = buildNode(nodeLike);
+    nodeMap.set(nodeLike, built);
+    return built;
+  }
+  return buildNode(nodeLike);
+}
+__name(getOrBuildNode, "getOrBuildNode");
+function processExplicitEdge({
+  edge,
+  nodeMap,
+  out
+}) {
+  out.push(
+    new Edge(
+      getOrBuildNode(edge.fromNode, nodeMap),
+      getOrBuildNode(edge.toNode, nodeMap),
+      edge.route
+    )
+  );
+}
+__name(processExplicitEdge, "processExplicitEdge");
+function processRoutingMapEdge({
+  fromEl,
+  toEl,
+  nodeMap,
+  out
+}) {
+  if (isPlainObject(fromEl)) {
+    throw new Error(
+      "Consecutive routing maps are not allowed in a chain. Split them into separate edge items."
+    );
+  }
+  for (const [expFrom, expTo, route] of expandRoutingMap(fromEl, toEl)) {
+    for (const fromNode of flattenElement(expFrom)) {
+      for (const toNode of flattenElement(expTo)) {
+        out.push(
+          new Edge(
+            getOrBuildNode(fromNode, nodeMap),
+            getOrBuildNode(toNode, nodeMap),
+            route
+          )
+        );
+      }
+    }
+  }
+}
+__name(processRoutingMapEdge, "processRoutingMapEdge");
+function processUnconditionalEdge({
+  fromEl,
+  toEl,
+  nodeMap,
+  out
+}) {
+  for (const fromNode of flattenElement(fromEl)) {
+    for (const toNode of flattenElement(toEl)) {
+      out.push(
+        new Edge(
+          getOrBuildNode(fromNode, nodeMap),
+          getOrBuildNode(toNode, nodeMap),
+          null
+        )
+      );
+    }
+  }
+}
+__name(processUnconditionalEdge, "processUnconditionalEdge");
+function processChain({
+  chain,
+  nodeMap,
+  out
+}) {
+  for (let i = 0; i < chain.length - 1; i++) {
+    const fromEl = chain[i];
+    const toEl = chain[i + 1];
+    if (isPlainObject(toEl)) {
+      processRoutingMapEdge({ fromEl, toEl, nodeMap, out });
+    } else {
+      processUnconditionalEdge({ fromEl, toEl, nodeMap, out });
+    }
+  }
+}
+__name(processChain, "processChain");
+function parseEdgeItems(edgeItems) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const item of edgeItems) {
+    if (isEdge(item)) {
+      processExplicitEdge({ edge: item, nodeMap, out });
+    } else if (Array.isArray(item)) {
+      processChain({ chain: item, nodeMap, out });
+    } else {
+      throw new Error(`Invalid edge item type: ${typeof item}`);
+    }
+  }
+  return out;
+}
+__name(parseEdgeItems, "parseEdgeItems");
+export {
+  parseEdgeItems
+};