@google/adk 1.6.0 → 2.0.0

package/dist/cjs/workflow/workflow.js

@@ -0,0 +1,509 @@
+/**
+  * @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 __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;
+};
+var workflow_exports = {};
+__export(workflow_exports, {
+  Workflow: () => Workflow,
+  isWorkflow: () => isWorkflow
+});
+module.exports = __toCommonJS(workflow_exports);
+var import_api = require("@opentelemetry/api");
+var import_tracing = require("../telemetry/tracing.js");
+var import_experimental = require("../utils/experimental.js");
+var import_base_node = require("./base_node.js");
+var import_branch_path = require("./branch_path.js");
+var import_dynamic_node_scheduler = require("./dynamic_node_scheduler.js");
+var import_errors = require("./errors.js");
+var import_graph = require("./graph.js");
+var import_node_error_event = require("./node_error_event.js");
+var import_node_runner = require("./node_runner.js");
+var import_node_state = require("./node_state.js");
+var import_node_status = require("./node_status.js");
+var import_schedule_dynamic_node = require("./schedule_dynamic_node.js");
+var import_rehydration_utils = require("./utils/rehydration_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+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 = import_base_node.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 = (0, import_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 import_schedule_dynamic_node.DynamicNodeState();
+    const abort = createWorkflowAbort(ctx.invocationContext.abortSignal);
+    ctx.scheduler = new import_dynamic_node_scheduler.DynamicNodeScheduler(
+      dynamicState,
+      abort.controller.signal
+    );
+    const span = import_tracing.tracer.startSpan(`invoke_workflow ${this.name}`);
+    try {
+      await import_api.context.with(import_api.trace.setSpan(import_api.context.active(), span), () => {
+        (0, import_tracing.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 = (0, import_rehydration_utils.eventsForCurrentRun)(
+      (_b2 = (_a2 = ctx.session) == null ? void 0 : _a2.events) != null ? _b2 : [],
+      ctx.invocationId
+    );
+    const rehydrated = (0, import_rehydration_utils.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 (0, import_rehydration_utils.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 = import_node_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 ((0, import_errors.isInvocationAbortedError)(error) || ((_a2 = loop.abortSignal) == null ? void 0 : _a2.aborted)) {
+      return;
+    }
+    if (!(0, import_node_error_event.claimNodeErrorReport)(error, ctx.invocationId)) {
+      return;
+    }
+    ctx.emit(
+      (0, import_node_error_event.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 === import_node_status.NodeStatus.RUNNING) {
+          continue;
+        }
+        if (state.status === import_node_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 = (0, import_node_state.createNodeState)({
+      runCounter: (_a2 = existing == null ? void 0 : existing.runCounter) != null ? _a2 : 0
+    });
+    state.input = trigger.input;
+    state.status = import_node_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 && (0, import_rehydration_utils.isFastForwardable)(prior)) {
+      loop.pending.set(
+        nodeName,
+        Promise.resolve({
+          name: nodeName,
+          childCtx: (0, import_rehydration_utils.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 = (0, import_node_runner.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 = import_node_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 = import_node_status.NodeStatus.WAITING;
+      return;
+    }
+    nodeState.status = import_node_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) === import_node_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 = (0, import_branch_path.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 === import_node_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([
+  import_experimental.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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Workflow,
+  isWorkflow
+});

package/dist/esm/a2a/a2a_event.js

@@ -1,5 +1,7 @@
 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
@@ -24,15 +26,19 @@ var TaskState = /* @__PURE__ */ ((TaskState2) => {
 function isTaskStatusUpdateEvent(event) {
   return (event == null ? void 0 : event.kind) === "status-update";
 }
+__name(isTaskStatusUpdateEvent, "isTaskStatusUpdateEvent");
 function isTaskArtifactUpdateEvent(event) {
   return (event == null ? void 0 : event.kind) === "artifact-update";
 }
+__name(isTaskArtifactUpdateEvent, "isTaskArtifactUpdateEvent");
 function isMessage(event) {
   return (event == null ? void 0 : event.kind) === "message";
 }
+__name(isMessage, "isMessage");
 function isTask(event) {
   return (event == null ? void 0 : event.kind) === "task";
 }
+__name(isTask, "isTask");
 function getEventMetadata(event) {
   if (isTaskArtifactUpdateEvent(event)) {
     return event.artifact.metadata || {};
@@ -42,9 +48,11 @@ function getEventMetadata(event) {
   }
   return {};
 }
+__name(getEventMetadata, "getEventMetadata");
 function isFailedTaskStatusUpdateEvent(event) {
   return (isTaskStatusUpdateEvent(event) || isTask(event)) && event.status.state === "failed" /* FAILED */;
 }
+__name(isFailedTaskStatusUpdateEvent, "isFailedTaskStatusUpdateEvent");
 function isTerminalTaskStatusUpdateEvent(event) {
   return (isTaskStatusUpdateEvent(event) || isTask(event)) && [
     "completed" /* COMPLETED */,
@@ -53,9 +61,11 @@ function isTerminalTaskStatusUpdateEvent(event) {
     "rejected" /* REJECTED */
   ].includes(event.status.state);
 }
+__name(isTerminalTaskStatusUpdateEvent, "isTerminalTaskStatusUpdateEvent");
 function isInputRequiredTaskStatusUpdateEvent(event) {
   return (isTaskStatusUpdateEvent(event) || isTask(event)) && event.status.state === "input-required" /* INPUT_REQUIRED */;
 }
+__name(isInputRequiredTaskStatusUpdateEvent, "isInputRequiredTaskStatusUpdateEvent");
 function getFailedTaskStatusUpdateEventError(event) {
   var _a;
   if (!isFailedTaskStatusUpdateEvent(event)) {
@@ -70,6 +80,7 @@ function getFailedTaskStatusUpdateEventError(event) {
   }
   return parts[0].text;
 }
+__name(getFailedTaskStatusUpdateEventError, "getFailedTaskStatusUpdateEventError");
 function createTaskSubmittedEvent({
   taskId,
   contextId,
@@ -89,6 +100,7 @@ function createTaskSubmittedEvent({
     metadata
   };
 }
+__name(createTaskSubmittedEvent, "createTaskSubmittedEvent");
 function createTask({
   contextId,
   message,
@@ -107,6 +119,7 @@ function createTask({
     metadata
   };
 }
+__name(createTask, "createTask");
 function createTaskWorkingEvent({
   taskId,
   contextId,
@@ -126,6 +139,7 @@ function createTaskWorkingEvent({
     metadata
   };
 }
+__name(createTaskWorkingEvent, "createTaskWorkingEvent");
 function createTaskCompletedEvent({
   taskId,
   contextId,
@@ -143,6 +157,7 @@ function createTaskCompletedEvent({
     metadata
   };
 }
+__name(createTaskCompletedEvent, "createTaskCompletedEvent");
 function createTaskArtifactUpdateEvent({
   taskId,
   contextId,
@@ -165,6 +180,7 @@ function createTaskArtifactUpdateEvent({
     metadata
   };
 }
+__name(createTaskArtifactUpdateEvent, "createTaskArtifactUpdateEvent");
 function createTaskFailedEvent({
   taskId,
   contextId,
@@ -196,6 +212,7 @@ function createTaskFailedEvent({
     metadata
   };
 }
+__name(createTaskFailedEvent, "createTaskFailedEvent");
 function createTaskInputRequiredEvent({
   taskId,
   contextId,
@@ -222,6 +239,7 @@ function createTaskInputRequiredEvent({
     metadata
   };
 }
+__name(createTaskInputRequiredEvent, "createTaskInputRequiredEvent");
 function createInputMissingErrorEvent({
   taskId,
   contextId,
@@ -248,6 +266,7 @@ function createInputMissingErrorEvent({
     metadata
   };
 }
+__name(createInputMissingErrorEvent, "createInputMissingErrorEvent");
 export {
   MessageRole,
   TaskState,

package/dist/esm/a2a/a2a_remote_agent.js

@@ -1,5 +1,7 @@
 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
@@ -23,7 +25,7 @@ import { resolveAgentCard } from "./agent_card.js";
 import { toAdkEvent } from "./event_converter_utils.js";
 import { getA2ASessionMetadata } from "./metadata_converter_utils.js";
 import { toA2AParts } from "./part_converter_utils.js";
-class RemoteA2AAgent extends BaseAgent {
+const _RemoteA2AAgent = class _RemoteA2AAgent extends BaseAgent {
   constructor(a2aConfig) {
     super(a2aConfig);
     this.a2aConfig = a2aConfig;
@@ -158,7 +160,9 @@ class RemoteA2AAgent extends BaseAgent {
   runLiveImpl(_context) {
     throw new Error("Live mode is not supported in A2ARemoteAgent yet.");
   }
-}
+};
+__name(_RemoteA2AAgent, "RemoteA2AAgent");
+let RemoteA2AAgent = _RemoteA2AAgent;
 export {
   AGENT_CARD_PATH,
   RemoteA2AAgent

package/dist/esm/a2a/a2a_remote_agent_run_processor.js

@@ -1,5 +1,7 @@
 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
@@ -8,6 +10,7 @@ const require = topLevelCreateRequire(import.meta.url);
 import {
   createModelContent
 } from "@google/genai";
+import { requireAgent } from "../agents/invocation_context.js";
 import { createEvent } from "../events/event.js";
 import {
   getEventMetadata,
@@ -16,7 +19,7 @@ import {
   isTaskStatusUpdateEvent
 } from "./a2a_event.js";
 import { A2AMetadataKeys } from "./metadata_converter_utils.js";
-class A2ARemoteAgentRunProcessor {
+const _A2ARemoteAgentRunProcessor = class _A2ARemoteAgentRunProcessor {
   constructor(request) {
     this.request = request;
     this.aggregations = /* @__PURE__ */ new Map();
@@ -127,7 +130,7 @@ class A2ARemoteAgentRunProcessor {
   buildNonPartialAggregation(context, agg) {
     this.promoteTextBlocksToParts(agg);
     const result = createEvent({
-      author: context.agent.name,
+      author: requireAgent(context).name,
       invocationId: context.invocationId,
       content: agg.parts.length > 0 ? createModelContent([...agg.parts]) : void 0,
       customMetadata: agg.customMeta,
@@ -178,7 +181,9 @@ class A2ARemoteAgentRunProcessor {
       event.customMetadata[`a2a:${k}`] = v;
     }
   }
-}
+};
+__name(_A2ARemoteAgentRunProcessor, "A2ARemoteAgentRunProcessor");
+let A2ARemoteAgentRunProcessor = _A2ARemoteAgentRunProcessor;
 export {
   A2ARemoteAgentRunProcessor
 };