@google/adk 1.6.0 → 2.1.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 = /* @__PURE__ */ 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/a2a_event.d.ts

@@ -120,7 +120,13 @@ export declare function createTaskFailedEvent({ taskId, contextId, error, metada
     metadata?: Record<string, unknown>;
 }): TaskStatusUpdateEvent;
 /**
- * Creates an input required event.
+ * Creates an input-required status update.
+ *
+ * A2A has one `input-required` state, so every reason an agent can pause for a
+ * human produces the same status update: a long-running tool asking for input,
+ * and a client message that left an earlier request unanswered. What separates
+ * them travels in `parts` — a validation failure carries a text part marked
+ * `validation_error` — not in the shape of the event, so both go through here.
  */
 export declare function createTaskInputRequiredEvent({ taskId, contextId, parts, metadata, }: {
     taskId: string;
@@ -128,12 +134,3 @@ export declare function createTaskInputRequiredEvent({ taskId, contextId, parts,
     parts: A2APart[];
     metadata?: Record<string, unknown>;
 }): TaskStatusUpdateEvent;
-/**
- * Creates an error message for missing input for a function call.
- */
-export declare function createInputMissingErrorEvent({ taskId, contextId, parts, metadata, }: {
-    parts: A2APart[];
-    taskId: string;
-    contextId: string;
-    metadata?: Record<string, unknown>;
-}): TaskStatusUpdateEvent;

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

@@ -65,6 +65,11 @@ export interface RemoteA2AAgentConfig extends BaseAgentConfig {
      * Callbacks run after receiving a response chunk or event, before conversion.
      */
     afterRequestCallbacks?: AfterA2ARequestCallback[];
+    /**
+     * Optional request-level metadata to include in the A2A message send request.
+     * If omitted, defaults to `context.a2aMetadata` from the current invocation context.
+     */
+    metadata?: Record<string, unknown>;
 }
 /**
  * RemoteA2AAgent delegates execution to a remote agent using the A2A protocol.

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

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Part as A2APart } from '@a2a-js/sdk';
+import { Content } from '@google/genai';
 import { InvocationContext } from '../agents/invocation_context.js';
 import { Event as AdkEvent } from '../events/event.js';
 import { Session } from '../sessions/session.js';
@@ -38,6 +39,30 @@ export declare function isFunctionCallEvent(event: AdkEvent, callId: string): bo
  *   none is found.
  */
 export declare function getFunctionResponseCallId(event: AdkEvent): string | undefined;
+/**
+ * Ids of credential requests the remote peer raised itself. An id that ANY
+ * non-peer event also issued a call for is excluded: the peer authors its
+ * own session events under its own name (`toAdkEvent` forces
+ * `author = this.name`) and controls `functionCall.id` verbatim, so a bare
+ * id match -- without checking whether some OTHER event also issued a call
+ * for that same id -- would let a peer re-label this agent's own pending
+ * credential request as one the peer had asked for, by sending an
+ * unrelated reply that happens to carry a function_call part whose id
+ * collides with it.
+ */
+export declare function peerRequestedCallIds(events: readonly AdkEvent[], peerName: string): ReadonlySet<string>;
+/**
+ * Converts genai parts to A2A parts for forwarding to the remote peer,
+ * scrubbing credential material the peer did not itself request.
+ *
+ * NOT the single point both session-forwarding paths converge on:
+ * `toMissingRemoteSessionParts` calls `withoutCredentialParts` directly,
+ * since it has to interleave `presentAsUserMessage` between the scrub and
+ * `toA2AParts`. The shared guarantee lives one level down, in
+ * `withoutCredentialParts` -- a third path calling `toA2AParts` directly
+ * would still bypass it.
+ */
+export declare function toForwardableA2AParts(content: Content | undefined, longRunningToolIds: string[] | undefined, peerRequestedIds: ReadonlySet<string>): A2APart[];
 /**
  * Returns A2A content parts for all events not yet seen by the remote agent,
  * along with the A2A context ID found in the most recent remote agent event.