@google/adk 1.6.0 → 2.0.0

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

@@ -0,0 +1,115 @@
+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 { isBaseNode, START } from "../base_node.js";
+import { NODE_BUILDERS, PARALLEL_WORKER_FACTORY } from "../node_builders.js";
+import { prepareRetryConfig } from "../retry_config.js";
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+__name(isPlainObject, "isPlainObject");
+function isNodeLike(value) {
+  return value === "START" || isBaseNode(value) || NODE_BUILDERS.some((builder) => builder.match(value));
+}
+__name(isNodeLike, "isNodeLike");
+function buildNode(nodeLike, options = {}) {
+  if (options.maxParallelWorkers !== void 0 && !options.parallelWorker) {
+    throw new Error(
+      "maxParallelWorkers can only be set when parallelWorker is true."
+    );
+  }
+  const built = buildInnerNode(nodeLike, options);
+  if (options.parallelWorker) {
+    if (nodeLike === "START") {
+      throw new Error("ParallelWorker cannot wrap a START node.");
+    }
+    if (!PARALLEL_WORKER_FACTORY) {
+      throw new Error(
+        "parallelWorker was requested but no ParallelWorker is available; the parallel worker node module is not part of this build."
+      );
+    }
+    return PARALLEL_WORKER_FACTORY(built, {
+      maxParallelWorkers: options.maxParallelWorkers
+    });
+  }
+  return built;
+}
+__name(buildNode, "buildNode");
+function buildInnerNode(nodeLike, options) {
+  if (nodeLike === "START") {
+    return START;
+  }
+  if (isBaseNode(nodeLike)) {
+    return cloneWithOverrides(nodeLike, options);
+  }
+  for (const builder of NODE_BUILDERS) {
+    if (builder.match(nodeLike)) {
+      return builder.build(nodeLike, options);
+    }
+  }
+  throw new Error(
+    `build_node: unsupported node-like value of type ${typeof nodeLike}. Import the node module that handles it (e.g. via the workflow barrel).`
+  );
+}
+__name(buildInnerNode, "buildInnerNode");
+const OVERRIDABLE_KEYS = [
+  "name",
+  "description",
+  "rerunOnResume",
+  "retryConfig",
+  "timeout",
+  "inputSchema",
+  "outputSchema",
+  "stateSchema",
+  "isolationScope"
+];
+const NODE_DECLARED_KEYS = ["authConfig"];
+function cloneWithOverrides(node, options) {
+  const overrides = {};
+  for (const key of OVERRIDABLE_KEYS) {
+    if (options[key] !== void 0) {
+      overrides[key] = options[key];
+    }
+  }
+  for (const key of NODE_DECLARED_KEYS) {
+    if (options[key] !== void 0 && key in node) {
+      overrides[key] = options[key];
+    }
+  }
+  if (Object.keys(overrides).length === 0) {
+    return node;
+  }
+  if (typeof overrides["name"] === "string") {
+    const name = overrides["name"].trim();
+    if (!name) {
+      throw new Error("Node name must be a non-empty string.");
+    }
+    overrides["name"] = name;
+  }
+  const clone = Object.create(
+    Object.getPrototypeOf(node)
+  );
+  Object.assign(clone, node, overrides);
+  if ("retryConfig" in overrides) {
+    Object.assign(clone, {
+      preparedRetryConfig: options.retryConfig ? prepareRetryConfig(options.retryConfig) : void 0
+    });
+  }
+  return clone;
+}
+__name(cloneWithOverrides, "cloneWithOverrides");
+export {
+  buildNode,
+  isNodeLike,
+  isPlainObject
+};

package/dist/esm/workflow/workflow.js

@@ -0,0 +1,493 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+import { context, trace } from "@opentelemetry/api";
+import { tracer, traceWorkflowInvocation } from "../telemetry/tracing.js";
+import { experimental } from "../utils/experimental.js";
+import { BaseNode } from "./base_node.js";
+import { commonPrefixOf } from "./branch_path.js";
+import { DynamicNodeScheduler } from "./dynamic_node_scheduler.js";
+import { isInvocationAbortedError } from "./errors.js";
+import {
+  createGraphFromEdgeItems
+} from "./graph.js";
+import {
+  claimNodeErrorReport,
+  createNodeErrorEvent
+} from "./node_error_event.js";
+import { executeChildNode } from "./node_runner.js";
+import { createNodeState } from "./node_state.js";
+import { NodeStatus } from "./node_status.js";
+import { DynamicNodeState } from "./schedule_dynamic_node.js";
+import {
+  eventsForCurrentRun,
+  isFastForwardable,
+  makeFastForwardResult,
+  reconstructNodeRuns,
+  resolvedInterruptResponses
+} from "./utils/rehydration_utils.js";
+const WORKFLOW_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.workflow");
+const _LoopState = class _LoopState {
+  constructor() {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.nodeOutputs = /* @__PURE__ */ new Map();
+    this.nodeBranches = /* @__PURE__ */ new Map();
+    this.triggerBuffer = /* @__PURE__ */ new Map();
+    this.pending = /* @__PURE__ */ new Map();
+    this.interruptIds = /* @__PURE__ */ new Set();
+    /** Per-node state reconstructed from prior session events (resume). */
+    this.rehydrated = /* @__PURE__ */ new Map();
+    /** Nodes already activated in this turn, so a repeat activation is visible. */
+    this.activated = /* @__PURE__ */ new Set();
+    this.errorShutDown = false;
+  }
+};
+__name(_LoopState, "LoopState");
+let LoopState = _LoopState;
+let Workflow = class extends (_b = BaseNode, _a = WORKFLOW_SIGNATURE_SYMBOL, _b) {
+  constructor(config) {
+    var _a2;
+    super({ ...config, rerunOnResume: (_a2 = config.rerunOnResume) != null ? _a2 : true });
+    /** Brand identifying this object as a {@link Workflow} (see `isWorkflow`). */
+    this[_a] = true;
+    const hasEdges = !!config.edges && config.edges.length > 0;
+    if (hasEdges && config.dynamicEntry) {
+      throw new Error(
+        `Workflow "${this.name}": "edges" and "dynamicEntry" are mutually exclusive.`
+      );
+    }
+    if (!hasEdges && !config.dynamicEntry) {
+      throw new Error(
+        `Workflow "${this.name}" requires either "edges" or "dynamicEntry".`
+      );
+    }
+    if (config.maxConcurrency !== void 0 && (!Number.isInteger(config.maxConcurrency) || config.maxConcurrency < 1)) {
+      throw new Error(
+        `Workflow "${this.name}": "maxConcurrency" must be a positive integer (got ${config.maxConcurrency}).`
+      );
+    }
+    this.maxConcurrency = config.maxConcurrency;
+    this.dynamicEntry = config.dynamicEntry;
+    if (config.edges && config.edges.length > 0) {
+      this.graph = createGraphFromEdgeItems(config.edges);
+    }
+  }
+  // eslint-disable-next-line require-yield -- child events stream out via ctx.channel/ctx.runNode; this orchestration generator itself yields nothing
+  async *runImpl(ctx, nodeInput) {
+    const dynamicState = new DynamicNodeState();
+    const abort = createWorkflowAbort(ctx.invocationContext.abortSignal);
+    ctx.scheduler = new DynamicNodeScheduler(
+      dynamicState,
+      abort.controller.signal
+    );
+    const span = tracer.startSpan(`invoke_workflow ${this.name}`);
+    try {
+      await context.with(trace.setSpan(context.active(), span), () => {
+        traceWorkflowInvocation({
+          workflowName: this.name,
+          nodePath: ctx.nodePath,
+          sessionId: ctx.invocationContext.session.id
+        });
+        return this.orchestrate(ctx, nodeInput, dynamicState, abort.controller);
+      });
+    } finally {
+      abort.dispose();
+      span.end();
+    }
+  }
+  /**
+   * The orchestration body, wrapped by {@link runImpl} so its workflow-scoped
+   * abort controller is always disposed.
+   */
+  async orchestrate(ctx, nodeInput, dynamicState, abortController) {
+    var _a2, _b2;
+    const runEvents = eventsForCurrentRun(
+      (_b2 = (_a2 = ctx.session) == null ? void 0 : _a2.events) != null ? _b2 : [],
+      ctx.invocationId
+    );
+    const rehydrated = reconstructNodeRuns(
+      runEvents,
+      ctx.nodePath || void 0
+    );
+    this.applyResumeInputs(ctx, runEvents);
+    if (this.dynamicEntry) {
+      await this.runDynamicEntry(ctx, nodeInput, dynamicState);
+      return;
+    }
+    const loop = new LoopState();
+    loop.rehydrated = rehydrated;
+    loop.abortSignal = abortController.signal;
+    this.seedStartTriggers(loop, nodeInput);
+    await this.runLoop(loop, ctx, abortController);
+    if (loop.errorShutDown) {
+      return;
+    }
+    this.collectRemainingInterrupts(loop);
+    for (const id of dynamicState.interruptIds) {
+      loop.interruptIds.add(id);
+    }
+    this.finalize(loop, ctx);
+  }
+  /**
+   * Runs an imperative `dynamicEntry` workflow. The entry drives execution via
+   * `ctx.runNode(...)` (routed through the scheduler) and returns the output.
+   */
+  async runDynamicEntry(ctx, nodeInput, dynamicState) {
+    const output = await this.dynamicEntry(ctx, nodeInput);
+    if (dynamicState.interruptIds.size > 0) {
+      ctx.interruptIds = [...dynamicState.interruptIds];
+      return;
+    }
+    if (output !== void 0) {
+      ctx.output = output;
+    }
+  }
+  /**
+   * Merges resolved interrupt responses from prior session events into
+   * `ctx.resumeInputs`, so waiting nodes (which read `ctx.resumeInputs[id]`)
+   * resume with the user's response. Shared by child contexts via propagation.
+   *
+   * Taken from the events rather than from `rehydrated`, because that view is
+   * scoped to this workflow's direct children: an interrupt raised deeper — by
+   * a `ctx.runNode` child, or inside a nested workflow — is keyed out of it,
+   * and its answer would never reach the node waiting on it.
+   */
+  applyResumeInputs(ctx, runEvents) {
+    for (const [interruptId, response] of resolvedInterruptResponses(
+      runEvents
+    )) {
+      ctx.resumeInputs[interruptId] = response;
+    }
+  }
+  // --- SETUP ---
+  seedStartTriggers(loop, nodeInput) {
+    const startEdges = this.graph.edges.filter(
+      (e) => e.fromNode.name === "__START__"
+    );
+    const useSubBranch = startEdges.length > 1;
+    for (const edge of startEdges) {
+      this.pushTrigger(loop, edge.toNode.name, {
+        input: nodeInput,
+        useSubBranch
+      });
+    }
+  }
+  // --- LOOP ---
+  async runLoop(loop, ctx, abortController) {
+    for (; ; ) {
+      this.scheduleReadyNodes(loop, ctx);
+      if (loop.pending.size === 0) {
+        break;
+      }
+      const result = await Promise.race(loop.pending.values());
+      loop.pending.delete(result.name);
+      if (result.error) {
+        const nodeState = loop.nodes.get(result.name);
+        if (nodeState) {
+          nodeState.status = NodeStatus.FAILED;
+        }
+        this.reportNodeError(loop, ctx, result.name, result.error);
+        loop.errorShutDown = true;
+        await this.cleanupPending(loop, abortController);
+        throw result.error;
+      }
+      await this.handleCompletion(loop, result.name, result.childCtx);
+    }
+  }
+  reportNodeError(loop, ctx, nodeName, error) {
+    var _a2, _b2, _c;
+    if (isInvocationAbortedError(error) || ((_a2 = loop.abortSignal) == null ? void 0 : _a2.aborted)) {
+      return;
+    }
+    if (!claimNodeErrorReport(error, ctx.invocationId)) {
+      return;
+    }
+    ctx.emit(
+      createNodeErrorEvent({
+        error,
+        attemptCount: (_c = (_b2 = loop.nodes.get(nodeName)) == null ? void 0 : _b2.attemptCount) != null ? _c : 1,
+        author: nodeName,
+        invocationId: ctx.invocationId,
+        nodeInfo: {
+          path: ctx.nodePath ? `${ctx.nodePath}.${nodeName}` : nodeName
+        },
+        branch: ctx.branch,
+        isolationScope: ctx.isolationScope
+      })
+    );
+  }
+  // --- Scheduling ---
+  scheduleReadyNodes(loop, ctx) {
+    for (const nodeName of [...loop.triggerBuffer.keys()]) {
+      if (loop.pending.has(nodeName)) {
+        continue;
+      }
+      const state = loop.nodes.get(nodeName);
+      if (state) {
+        if (state.status === NodeStatus.RUNNING) {
+          continue;
+        }
+        if (state.status === NodeStatus.WAITING && state.interrupts.length > 0) {
+          continue;
+        }
+      }
+      if (this.atConcurrencyLimit(loop)) {
+        break;
+      }
+      const trigger = this.popTrigger(loop, nodeName);
+      if (!trigger) {
+        continue;
+      }
+      this.prepareNodeStateForStarting(loop, nodeName, trigger);
+      this.startNodeTask(loop, ctx, nodeName, trigger);
+    }
+  }
+  atConcurrencyLimit(loop) {
+    return this.maxConcurrency !== void 0 && loop.pending.size >= this.maxConcurrency;
+  }
+  prepareNodeStateForStarting(loop, nodeName, trigger) {
+    var _a2;
+    const existing = loop.nodes.get(nodeName);
+    const state = createNodeState({
+      runCounter: (_a2 = existing == null ? void 0 : existing.runCounter) != null ? _a2 : 0
+    });
+    state.input = trigger.input;
+    state.status = NodeStatus.RUNNING;
+    loop.nodes.set(nodeName, state);
+  }
+  startNodeTask(loop, ctx, nodeName, trigger) {
+    var _a2, _b2;
+    const node = this.getStaticNode(nodeName);
+    const nodeState = loop.nodes.get(nodeName);
+    const repeatActivation = loop.activated.has(nodeName);
+    loop.activated.add(nodeName);
+    const prior = (_a2 = loop.rehydrated.get(nodeName)) == null ? void 0 : _a2.shift();
+    if (prior && isFastForwardable(prior)) {
+      loop.pending.set(
+        nodeName,
+        Promise.resolve({
+          name: nodeName,
+          childCtx: makeFastForwardResult(ctx, prior)
+        })
+      );
+      return;
+    }
+    if (prior && !node.rerunOnResume && prior.output === void 0 && prior.interruptIds.size > 0) {
+      const values = [...prior.interruptIds].map((id) => ctx.resumeInputs[id]);
+      if (values.every((v) => v !== void 0)) {
+        const output = values.length === 1 ? values[0] : values;
+        const resumeResult = {
+          output,
+          route: void 0,
+          branch: (_b2 = prior.branch) != null ? _b2 : ctx.branch,
+          interruptIds: []
+        };
+        loop.pending.set(
+          nodeName,
+          Promise.resolve({ name: nodeName, childCtx: resumeResult })
+        );
+        return;
+      }
+    }
+    let runId = nodeState.runId;
+    if (!runId) {
+      nodeState.runCounter += 1;
+      runId = String(nodeState.runCounter);
+      nodeState.runId = runId;
+    }
+    const resuming = prior !== void 0 && prior.interruptIds.size > 0 && prior.input !== void 0;
+    const nodeInput = resuming ? prior.input : trigger.input;
+    const task = executeChildNode({
+      parent: ctx,
+      node,
+      input: nodeInput,
+      abortSignal: loop.abortSignal,
+      nodeState,
+      resumeInputs: repeatActivation ? {} : void 0,
+      options: {
+        runId,
+        useSubBranch: trigger.useSubBranch,
+        overrideBranch: trigger.branch,
+        overrideIsolationScope: trigger.isolationScope
+      }
+    }).then(
+      (childCtx) => ({ name: nodeName, childCtx }),
+      (error) => ({ name: nodeName, error })
+    );
+    loop.pending.set(nodeName, task);
+  }
+  // --- Completion handling ---
+  async handleCompletion(loop, nodeName, childCtx) {
+    var _a2;
+    const nodeState = loop.nodes.get(nodeName);
+    const node = this.getStaticNode(nodeName);
+    if (childCtx.interruptIds.length > 0) {
+      nodeState.status = NodeStatus.WAITING;
+      nodeState.interrupts = [...childCtx.interruptIds];
+      childCtx.interruptIds.forEach((id) => loop.interruptIds.add(id));
+      return;
+    }
+    if (node.waitForOutput && childCtx.output === void 0 && childCtx.route === void 0) {
+      nodeState.status = NodeStatus.WAITING;
+      return;
+    }
+    nodeState.status = NodeStatus.COMPLETED;
+    if (childCtx.output !== void 0) {
+      loop.nodeOutputs.set(nodeName, childCtx.output);
+    }
+    loop.nodeBranches.set(nodeName, (_a2 = childCtx.branch) != null ? _a2 : "");
+    this.bufferDownstreamTriggers(
+      loop,
+      nodeName,
+      childCtx.output,
+      childCtx.route,
+      childCtx.branch
+    );
+  }
+  bufferDownstreamTriggers(loop, nodeName, output, route, branch) {
+    const nextNodes = this.graph.getNextPendingNodes(nodeName, route != null ? route : null);
+    const useSubBranch = nextNodes.length > 1;
+    for (const targetName of nextNodes) {
+      const targetNode = this.getStaticNode(targetName);
+      if (targetNode.requiresAllPredecessors) {
+        const predecessors = new Set(
+          this.graph.edges.filter((e) => e.toNode.name === targetName).map(
+            (e) => e.fromNode.name
+          )
+        );
+        const allCompleted = [...predecessors].every(
+          (p) => {
+            var _a2;
+            return ((_a2 = loop.nodes.get(p)) == null ? void 0 : _a2.status) === NodeStatus.COMPLETED;
+          }
+        );
+        if (allCompleted) {
+          const outputs = {};
+          for (const p of predecessors) {
+            outputs[p] = loop.nodeOutputs.get(p);
+          }
+          const branches = [...predecessors].map(
+            (p) => {
+              var _a2;
+              return (_a2 = loop.nodeBranches.get(p)) != null ? _a2 : "";
+            }
+          );
+          const commonBranch = commonPrefixOf(branches);
+          this.pushTrigger(loop, targetName, {
+            input: outputs,
+            useSubBranch: false,
+            branch: commonBranch || void 0
+          });
+        }
+      } else {
+        this.pushTrigger(loop, targetName, {
+          input: output,
+          useSubBranch,
+          branch
+        });
+      }
+    }
+  }
+  collectRemainingInterrupts(loop) {
+    for (const nodeState of loop.nodes.values()) {
+      if (nodeState.status === NodeStatus.WAITING && nodeState.interrupts.length > 0) {
+        nodeState.interrupts.forEach((id) => loop.interruptIds.add(id));
+      }
+    }
+  }
+  // --- FINALIZE ---
+  finalize(loop, ctx) {
+    if (loop.interruptIds.size > 0) {
+      ctx.interruptIds = [...loop.interruptIds];
+      return;
+    }
+    const terminalOutputs = [...this.graph.terminalNodeNames].filter((name) => loop.nodeOutputs.has(name)).map((name) => loop.nodeOutputs.get(name));
+    if (terminalOutputs.length === 1) {
+      ctx.output = terminalOutputs[0];
+    } else if (terminalOutputs.length > 1) {
+      throw new Error(
+        `Workflow ${this.name}: multiple terminal nodes produced output (${terminalOutputs.length}). A workflow must have at most one terminal output.`
+      );
+    }
+  }
+  // --- Utilities ---
+  pushTrigger(loop, nodeName, trigger) {
+    const buffer = loop.triggerBuffer.get(nodeName);
+    if (buffer) {
+      buffer.push(trigger);
+    } else {
+      loop.triggerBuffer.set(nodeName, [trigger]);
+    }
+  }
+  popTrigger(loop, nodeName) {
+    const buffer = loop.triggerBuffer.get(nodeName);
+    if (!buffer || buffer.length === 0) {
+      return void 0;
+    }
+    const trigger = buffer.shift();
+    if (buffer.length === 0) {
+      loop.triggerBuffer.delete(nodeName);
+    }
+    return trigger;
+  }
+  getStaticNode(name) {
+    const node = this.graph.nodes.find((n) => n.name === name);
+    if (!node) {
+      throw new Error(`Node ${name} not found in graph.`);
+    }
+    return node;
+  }
+  async cleanupPending(loop, abortController) {
+    abortController.abort();
+    const outstanding = [...loop.pending.values()];
+    loop.pending.clear();
+    await Promise.allSettled(outstanding);
+  }
+};
+__name(Workflow, "Workflow");
+Workflow = __decorateClass([
+  experimental
+], Workflow);
+function isWorkflow(value) {
+  return typeof value === "object" && value !== null && WORKFLOW_SIGNATURE_SYMBOL in value && value[WORKFLOW_SIGNATURE_SYMBOL] === true;
+}
+__name(isWorkflow, "isWorkflow");
+function createWorkflowAbort(parentSignal) {
+  const controller = new AbortController();
+  if (!parentSignal) {
+    return { controller, dispose: /* @__PURE__ */ __name(() => {
+    }, "dispose") };
+  }
+  if (parentSignal.aborted) {
+    controller.abort();
+    return { controller, dispose: /* @__PURE__ */ __name(() => {
+    }, "dispose") };
+  }
+  const onParentAbort = /* @__PURE__ */ __name(() => controller.abort(), "onParentAbort");
+  parentSignal.addEventListener("abort", onParentAbort, { once: true });
+  return {
+    controller,
+    dispose: /* @__PURE__ */ __name(() => parentSignal.removeEventListener("abort", onParentAbort), "dispose")
+  };
+}
+__name(createWorkflowAbort, "createWorkflowAbort");
+export {
+  Workflow,
+  isWorkflow
+};

package/dist/types/a2a/agent_card.d.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { AgentCard, AgentInterface, AgentSkill } from '@a2a-js/sdk';
-import { BaseAgent } from '../agents/base_agent.js';
+import { RunnableRoot } from '../workflow/run_node_as_invocation.js';
 /**
  * Resolves the AgentCard from the provided source.
  */
@@ -12,7 +12,7 @@ export declare function resolveAgentCard(agentCard: AgentCard | string): Promise
 /**
  * Converts an ADK agent to an A2A AgentCard.
  */
-export declare function getA2AAgentCard(agent: BaseAgent, transports: AgentInterface[]): Promise<AgentCard>;
+export declare function getA2AAgentCard(agent: RunnableRoot, transports: AgentInterface[]): Promise<AgentCard>;
 /**
  * Builds a list of AgentSkills based on agent descriptions and types.
  * This information can be used in AgentCard to help clients understand agent capabilities.
@@ -20,4 +20,4 @@ export declare function getA2AAgentCard(agent: BaseAgent, transports: AgentInter
  * @param agent The agent to build skills for.
  * @returns A promise resolving to a list of AgentSkills.
  */
-export declare function buildAgentSkills(agent: BaseAgent): Promise<AgentSkill[]>;
+export declare function buildAgentSkills(agent: RunnableRoot): Promise<AgentSkill[]>;

package/dist/types/a2a/agent_to_a2a.d.ts

@@ -4,13 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { AgentCard } from '@a2a-js/sdk';
-import { UserBuilder } from '@a2a-js/sdk/server/express';
-import express from 'express';
-import { BaseAgent } from '../agents/base_agent.js';
+import type { UserBuilder } from '@a2a-js/sdk/server/express';
+import type express from 'express';
 import { BaseArtifactService } from '../artifacts/base_artifact_service.js';
 import { BaseMemoryService } from '../memory/base_memory_service.js';
 import { Runner } from '../runner/runner.js';
 import { BaseSessionService } from '../sessions/base_session_service.js';
+import { RunnableRoot } from '../workflow/run_node_as_invocation.js';
 /**
  * A request authenticator for the A2A surface.
  *
@@ -80,4 +80,4 @@ export interface ToA2aOptions {
  * @param options Configuration options
  * @returns An Express application
  */
-export declare function toA2a(agent: BaseAgent, options?: ToA2aOptions): Promise<express.Application>;
+export declare function toA2a(agent: RunnableRoot, options?: ToA2aOptions): Promise<express.Application>;

package/dist/types/a2a/event_processor_utils.d.ts

@@ -19,6 +19,21 @@ import { ExecutorContext } from './executor_context.js';
  */
 export declare function getFinalTaskStatusUpdate(adkEvents: AdkEvent[], context: ExecutorContext): TaskStatusUpdateEvent;
 /**
- * Returns input required task status update events if the provided user request does not contain responses for all function calls in the task status.
+ * Returns an input-required status update when the incoming message leaves a
+ * pending request unanswered.
+ *
+ * A pause belongs to the conversation, not to the task that happened to raise
+ * it: the ADK session is keyed by `contextId`, and a client picks its own task
+ * ids. Scoping this to `ctx.task` alone let a caller step around an open gate
+ * by starting a new task in the same context and going on talking to an agent
+ * that is supposed to be waiting on a human. Pending requests are therefore
+ * read from the session as well as from the task, and each one has to be
+ * answered before the agent runs again.
  */
-export declare function getTaskInputRequiredEvent(task: Task, genAIContent: GenAIContent): TaskStatusUpdateEvent | undefined;
+export declare function getUnansweredRequestEvent(options: {
+    taskId: string;
+    contextId: string;
+    task?: Task;
+    sessionEvents: AdkEvent[];
+    genAIContent: GenAIContent;
+}): TaskStatusUpdateEvent | undefined;

package/dist/types/a2a/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * `@google/adk/a2a` subpath: the A2A surface only, without the full ADK barrel.
+ * Also re-exported from `@google/adk`.
+ */
+export { AGENT_CARD_PATH, RemoteA2AAgent } from './a2a_remote_agent.js';
+export type { A2AStreamEventData, AfterA2ARequestCallback, BeforeA2ARequestCallback, RemoteA2AAgentConfig, } from './a2a_remote_agent.js';
+export { getA2AAgentCard } from './agent_card.js';
+export { A2AAgentExecutor } from './agent_executor.js';
+export type { AfterEventCallback, AfterExecuteCallback, AgentExecutorConfig, BeforeExecuteCallback, RunnerOrRunnerConfig, } from './agent_executor.js';
+export { toA2a } from './agent_to_a2a.js';
+export type { A2aUserBuilder, ToA2aOptions } from './agent_to_a2a.js';
+export { bearerTokenUserBuilder } from './auth.js';
+export type { ExecutorContext } from './executor_context.js';