@google/adk 2.3.0 → 2.5.0

package/dist/cjs/workflow/node_runner.js

@@ -28,11 +28,9 @@ __export(node_runner_exports, {
   executeChildNode: () => executeChildNode
 });
 module.exports = __toCommonJS(node_runner_exports);
-var import_api = require("@opentelemetry/api");
 var import_invocation_context = require("../agents/invocation_context.js");
 var import_event = require("../events/event.js");
-var import_tracing = require("../telemetry/tracing.js");
-var import_error_utils = require("../utils/error_utils.js");
+var import_instrumentation = require("../telemetry/api/instrumentation.js");
 var import_branch_path = require("./branch_path.js");
 var import_errors = require("./errors.js");
 var import_node_context = require("./node_context.js");
@@ -50,11 +48,12 @@ function executeChildNode(params) {
   const { parent, node, options = {} } = params;
   const nodeName = (_a = options.nodeName) != null ? _a : node.name;
   const nodePath = (_b = options.overrideNodePath) != null ? _b : parent.nodePath ? `${parent.nodePath}.${nodeName}` : nodeName;
-  const span = import_tracing.tracer.startSpan(`execute_node ${nodeName}`);
-  return import_api.context.with(
-    import_api.trace.setSpan(import_api.context.active(), span),
-    () => runChildNode({ params, nodeName, nodePath, span })
-  );
+  const scope = (0, import_instrumentation.recordNodeInvocation)({
+    node,
+    nodeName,
+    sessionId: parent.invocationContext.session.id
+  });
+  return scope.run(() => runChildNode({ params, nodeName, nodePath, scope }));
 }
 __name(executeChildNode, "executeChildNode");
 async function runChildNode({
@@ -69,7 +68,7 @@ async function runChildNode({
   },
   nodeName,
   nodePath,
-  span
+  scope
 }) {
   var _a, _b, _c, _d;
   const runId = (_a = options.runId) != null ? _a : nodeName;
@@ -123,13 +122,6 @@ async function runChildNode({
       });
       if (skipOutput !== void 0) {
         child.output = skipOutput;
-        (0, import_tracing.traceNodeExecution)({
-          nodePath,
-          runId,
-          attempt: nodeState.attemptCount,
-          status: "completed",
-          interruptCount: child.interruptIds.length
-        });
         if (options.useAsOutput) {
           parent.output = child.output;
           parent.route = child.route;
@@ -143,16 +135,14 @@ async function runChildNode({
       resetState(child);
       child.attemptCount = nodeState.attemptCount;
       try {
-        inputRecorded = await runAttempt({
+        inputRecorded = await runOnce({
           node,
           child,
           input,
           nodeName,
           branch,
           isolationScope,
-          nodePath,
-          runId,
-          attempt: nodeState.attemptCount
+          scope
         });
         failIfNodeReportedError(child, nodeName);
         succeeded = true;
@@ -179,13 +169,6 @@ async function runChildNode({
     if (!inputRecorded && child.interruptIds.length > 0) {
       recordInputForResume({ child, nodeName, branch, isolationScope, input });
     }
-    (0, import_tracing.traceNodeExecution)({
-      nodePath,
-      runId,
-      attempt: nodeState.attemptCount,
-      status: child.interruptIds.length > 0 ? "waiting" : "completed",
-      interruptCount: child.interruptIds.length
-    });
     if (pluginManager == null ? void 0 : pluginManager.hasPlugins) {
       const replacedOutput = await pluginManager.runAfterNodeCallback({
         node,
@@ -203,58 +186,13 @@ async function runChildNode({
     }
     return child;
   } catch (err) {
-    (0, import_tracing.traceNodeExecution)({
-      nodePath,
-      runId,
-      attempt: nodeState.attemptCount,
-      status: "failed",
-      interruptCount: child.interruptIds.length
-    });
-    span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: (0, import_error_utils.formatError)(err) });
+    scope.end(err);
     throw err;
   } finally {
-    span.end();
+    scope.end();
   }
 }
 __name(runChildNode, "runChildNode");
-function runAttempt(params) {
-  const { node, nodePath, runId, attempt } = params;
-  if (!node.preparedRetryConfig) {
-    return runOnce(params);
-  }
-  return import_tracing.tracer.startActiveSpan(
-    `execute_node_attempt ${params.nodeName}`,
-    async (span) => {
-      try {
-        const inputRecorded = await runOnce(params);
-        (0, import_tracing.traceNodeExecution)({
-          nodePath,
-          runId,
-          attempt,
-          status: params.child.interruptIds.length > 0 ? "waiting" : "completed",
-          interruptCount: params.child.interruptIds.length
-        });
-        return inputRecorded;
-      } catch (err) {
-        (0, import_tracing.traceNodeExecution)({
-          nodePath,
-          runId,
-          attempt,
-          status: "failed",
-          interruptCount: params.child.interruptIds.length
-        });
-        span.setStatus({
-          code: import_api.SpanStatusCode.ERROR,
-          message: (0, import_error_utils.formatError)(err)
-        });
-        throw err;
-      } finally {
-        span.end();
-      }
-    }
-  );
-}
-__name(runAttempt, "runAttempt");
 function failIfNodeReportedError(child, nodeName) {
   const reported = child.reportedError;
   if (!reported || child.output !== void 0 || child.route !== void 0 || child.interruptIds.length > 0) {
@@ -281,11 +219,12 @@ async function runOnce({
   input,
   nodeName,
   branch,
-  isolationScope
+  isolationScope,
+  scope
 }) {
   var _a;
   let inputRecorded = false;
-  const consume = /* @__PURE__ */ __name((event) => {
+  const consume = /* @__PURE__ */ __name(async (event) => {
     var _a2, _b, _c;
     enrichEvent({ event, child, nodeName, branch, isolationScope });
     const emittedDelta = (_a2 = event.actions) == null ? void 0 : _a2.stateDelta;
@@ -324,13 +263,18 @@ async function runOnce({
       };
       inputRecorded = true;
     }
-    child.channel.push(event);
+    scope.recordEvent(event);
+    if (event.partial) {
+      child.channel.push(event);
+    } else {
+      await child.channel.pushAndWait(event);
+    }
   }, "consume");
   const parentSignal = child.invocationContext.abortSignal;
   const hasTimeout = typeof node.timeout === "number" && node.timeout > 0;
   if (!hasTimeout && !parentSignal) {
     for await (const event of node.run(child, input)) {
-      consume(event);
+      await consume(event);
     }
     return inputRecorded;
   }
@@ -338,7 +282,7 @@ async function runOnce({
     child.abortSignal = parentSignal;
     try {
       for await (const event of node.run(child, input)) {
-        consume(event);
+        await consume(event);
       }
     } finally {
       child.abortSignal = void 0;
@@ -378,7 +322,7 @@ async function runOnce({
   try {
     let result = await Promise.race([iterator.next(), aborted]);
     while (!result.done) {
-      consume(result.value);
+      await Promise.race([consume(result.value), aborted]);
       result = await Promise.race([iterator.next(), aborted]);
     }
   } finally {

package/dist/cjs/workflow/nodes/parallel_worker.js

@@ -25,7 +25,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var parallel_worker_exports = {};
 __export(parallel_worker_exports, {
-  ParallelWorker: () => ParallelWorker
+  ParallelWorker: () => ParallelWorker,
+  isParallelWorker: () => isParallelWorker
 });
 module.exports = __toCommonJS(parallel_worker_exports);
 var import_base_node = require("../base_node.js");
@@ -36,11 +37,16 @@ var import_workflow_graph_utils = require("../utils/workflow_graph_utils.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a, _b;
 const DEFAULT_MAX_PARALLEL_WORKERS = 8;
-const _ParallelWorker = class _ParallelWorker extends import_base_node.BaseNode {
+const PARALLEL_WORKER_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.workflow.parallelWorker"
+);
+const _ParallelWorker = class _ParallelWorker extends (_b = import_base_node.BaseNode, _a = PARALLEL_WORKER_SIGNATURE_SYMBOL, _b) {
   constructor(inner, config = {}) {
     const built = (0, import_workflow_graph_utils.buildNode)(inner);
     super({ name: built.name, rerunOnResume: true });
+    this[_a] = true;
     if (config.maxParallelWorkers !== void 0 && config.maxParallelWorkers < 1) {
       throw new Error("maxParallelWorkers must be greater than or equal to 1.");
     }
@@ -48,7 +54,7 @@ const _ParallelWorker = class _ParallelWorker extends import_base_node.BaseNode
     this.maxParallelWorkers = config.maxParallelWorkers;
   }
   async *runImpl(ctx, input) {
-    var _a;
+    var _a2;
     const items = Array.isArray(input) ? input : [input];
     if (items.length === 0) {
       yield [];
@@ -56,7 +62,7 @@ const _ParallelWorker = class _ParallelWorker extends import_base_node.BaseNode
     }
     const results = new Array(items.length);
     const poolSize = Math.min(
-      (_a = this.maxParallelWorkers) != null ? _a : DEFAULT_MAX_PARALLEL_WORKERS,
+      (_a2 = this.maxParallelWorkers) != null ? _a2 : DEFAULT_MAX_PARALLEL_WORKERS,
       items.length
     );
     let nextIndex = 0;
@@ -65,8 +71,8 @@ const _ParallelWorker = class _ParallelWorker extends import_base_node.BaseNode
     let interrupted = false;
     const interruptIds = [];
     const isAborted = /* @__PURE__ */ __name(() => {
-      var _a2, _b;
-      return ((_a2 = ctx.abortSignal) == null ? void 0 : _a2.aborted) === true || ((_b = ctx.invocationContext.abortSignal) == null ? void 0 : _b.aborted) === true;
+      var _a3, _b2;
+      return ((_a3 = ctx.abortSignal) == null ? void 0 : _a3.aborted) === true || ((_b2 = ctx.invocationContext.abortSignal) == null ? void 0 : _b2.aborted) === true;
     }, "isAborted");
     const worker = /* @__PURE__ */ __name(async () => {
       while (!failed && !interrupted && !isAborted()) {
@@ -123,7 +129,12 @@ const _ParallelWorker = class _ParallelWorker extends import_base_node.BaseNode
 };
 __name(_ParallelWorker, "ParallelWorker");
 let ParallelWorker = _ParallelWorker;
+function isParallelWorker(value) {
+  return typeof value === "object" && value !== null && PARALLEL_WORKER_SIGNATURE_SYMBOL in value && value[PARALLEL_WORKER_SIGNATURE_SYMBOL] === true;
+}
+__name(isParallelWorker, "isParallelWorker");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ParallelWorker
+  ParallelWorker,
+  isParallelWorker
 });

package/dist/cjs/workflow/run_llm_agent_as_node.js

@@ -42,9 +42,7 @@ async function* runLlmAgentAsNode(agent, ctx, nodeInput) {
   if (!isTaskMode && !agent.includeContentsExplicit) {
     agent.includeContents = "none";
   }
-  if (!isTaskMode) {
-    await appendNodeInputAsUserTurn(ctx, nodeInput);
-  }
+  const inputEvent = isTaskMode ? void 0 : pushNodeInputAsUserTurn(ctx, nodeInput);
   const agentIc = withWorkflowInstructionScope(ctx.getInvocationContext(), {
     input: nodeInput,
     outputsByNode: collectPredecessorOutputs(ctx)
@@ -53,15 +51,19 @@ async function* runLlmAgentAsNode(agent, ctx, nodeInput) {
     yield* runTaskMode(ctx, agentIc, agent);
     return;
   }
-  for await (const event of agent.runAsync(agentIc)) {
-    maybeSetOutput(agent, event);
-    yield event;
+  try {
+    for await (const event of agent.runAsync(agentIc)) {
+      maybeSetOutput(agent, event);
+      yield event;
+    }
+  } finally {
+    removeEvent(ctx.session.events, inputEvent);
   }
 }
 __name(runLlmAgentAsNode, "runLlmAgentAsNode");
-async function appendNodeInputAsUserTurn(ctx, nodeInput) {
+function pushNodeInputAsUserTurn(ctx, nodeInput) {
   if (nodeInput === void 0 || nodeInput === null) {
-    return;
+    return void 0;
   }
   const userEvent = (0, import_event.createEvent)({
     author: "user",
@@ -72,14 +74,17 @@ async function appendNodeInputAsUserTurn(ctx, nodeInput) {
   if (ctx.isolationScope !== void 0) {
     userEvent.isolationScope = ctx.isolationScope;
   }
-  const sessionService = ctx.invocationContext.sessionService;
-  if (sessionService) {
-    await sessionService.appendEvent({ session: ctx.session, event: userEvent });
-  } else {
-    ctx.session.events.push(userEvent);
+  ctx.session.events.push(userEvent);
+  return userEvent;
+}
+__name(pushNodeInputAsUserTurn, "pushNodeInputAsUserTurn");
+function removeEvent(events, event) {
+  const index = event ? events.indexOf(event) : -1;
+  if (index !== -1) {
+    events.splice(index, 1);
   }
 }
-__name(appendNodeInputAsUserTurn, "appendNodeInputAsUserTurn");
+__name(removeEvent, "removeEvent");
 async function* runTaskMode(ctx, agentIc, agent) {
   var _a, _b;
   const finishTool = agent.finishTaskTool;

package/dist/cjs/workflow/utils/retry_utils.js

@@ -42,7 +42,7 @@ const DEFAULT_MAX_DELAY_SECONDS = 60;
 const DEFAULT_BACKOFF_FACTOR = 2;
 const DEFAULT_JITTER = 1;
 function errorNames(error) {
-  var _a;
+  var _a, _b, _c;
   if (error instanceof Error) {
     const names = [(_a = error.constructor) == null ? void 0 : _a.name, error.name].filter(
       (name) => !!name
@@ -50,7 +50,7 @@ function errorNames(error) {
     return [...new Set(names)];
   }
   if (typeof error === "object" && error !== null) {
-    return [error.constructor.name];
+    return [(_c = (_b = error.constructor) == null ? void 0 : _b.name) != null ? _c : "Object"];
   }
   return [typeof error];
 }

package/dist/cjs/workflow/workflow.js

@@ -37,8 +37,7 @@ __export(workflow_exports, {
   isWorkflow: () => isWorkflow
 });
 module.exports = __toCommonJS(workflow_exports);
-var import_api = require("@opentelemetry/api");
-var import_tracing = require("../telemetry/tracing.js");
+var import_instrumentation = require("../telemetry/api/instrumentation.js");
 var import_experimental = require("../utils/experimental.js");
 var import_base_node = require("./base_node.js");
 var import_branch_path = require("./branch_path.js");
@@ -111,19 +110,20 @@ let Workflow = class extends (_b = import_base_node.BaseNode, _a = WORKFLOW_SIGN
       dynamicState,
       abort.controller.signal
     );
-    const span = import_tracing.tracer.startSpan(`invoke_workflow ${this.name}`);
+    const telemetryScope = (0, import_instrumentation.recordWorkflowInvocation)({
+      workflow: this,
+      sessionId: ctx.invocationContext.session.id
+    });
     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);
-      });
+      await telemetryScope.run(
+        () => this.orchestrate(ctx, nodeInput, dynamicState, abort.controller)
+      );
+    } catch (error) {
+      telemetryScope.end(error);
+      throw error;
     } finally {
       abort.dispose();
-      span.end();
+      telemetryScope.end();
     }
   }
   /**

package/dist/esm/a2a/a2a_remote_agent.js

@@ -10,9 +10,15 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 import {
   AGENT_CARD_PATH
 } from "@a2a-js/sdk";
-import { ClientFactory } from "@a2a-js/sdk/client";
+import {
+  ClientFactory,
+  ClientFactoryOptions,
+  JsonRpcTransportFactory,
+  RestTransportFactory
+} from "@a2a-js/sdk/client";
 import { BaseAgent } from "../agents/base_agent.js";
 import { createEvent } from "../events/event.js";
+import { propagateTraceContext } from "../telemetry/api/instrumentation.js";
 import { randomUUID } from "../utils/env_aware_utils.js";
 import { logger } from "../utils/logger.js";
 import { MessageRole } from "./a2a_event.js";
@@ -26,6 +32,18 @@ import {
 import { resolveAgentCard } from "./agent_card.js";
 import { toAdkEvent } from "./event_converter_utils.js";
 import { getA2ASessionMetadata } from "./metadata_converter_utils.js";
+function createTracePropagatingClientFactory() {
+  const fetchImpl = propagateTraceContext();
+  return new ClientFactory(
+    ClientFactoryOptions.createFrom(ClientFactoryOptions.default, {
+      transports: [
+        new JsonRpcTransportFactory({ fetchImpl }),
+        new RestTransportFactory({ fetchImpl })
+      ]
+    })
+  );
+}
+__name(createTracePropagatingClientFactory, "createTracePropagatingClientFactory");
 const _RemoteA2AAgent = class _RemoteA2AAgent extends BaseAgent {
   constructor(a2aConfig) {
     super(a2aConfig);
@@ -36,6 +54,7 @@ const _RemoteA2AAgent = class _RemoteA2AAgent extends BaseAgent {
     }
   }
   async init() {
+    var _a;
     if (this.isInitialized) {
       return;
     }
@@ -48,7 +67,7 @@ const _RemoteA2AAgent = class _RemoteA2AAgent extends BaseAgent {
         this.a2aConfig.resolveAgentCardOptions
       );
       if (!this.client) {
-        const factory = this.a2aConfig.clientFactory || new ClientFactory();
+        const factory = (_a = this.a2aConfig.clientFactory) != null ? _a : createTracePropagatingClientFactory();
         this.client = await factory.createFromAgentCard(this.card);
       }
     }
@@ -64,7 +83,8 @@ const _RemoteA2AAgent = class _RemoteA2AAgent extends BaseAgent {
       }
       const userFnCall = getUserFunctionCallAt(
         context.session,
-        events.length - 1
+        events.length - 1,
+        this.name
       );
       let parts;
       let taskId = void 0;

package/dist/esm/a2a/a2a_remote_agent_utils.js

@@ -14,7 +14,8 @@ import { camelCaseKeys } from "../utils/case_utils.js";
 import { logger } from "../utils/logger.js";
 import { AdkMetadataKeys } from "./metadata_converter_utils.js";
 import { toA2AParts } from "./part_converter_utils.js";
-function getUserFunctionCallAt(session, index) {
+function getUserFunctionCallAt(session, index, agentName) {
+  var _a, _b;
   const events = session.events;
   if (index < 0 || index >= events.length) {
     return void 0;
@@ -23,13 +24,16 @@ function getUserFunctionCallAt(session, index) {
   if (candidate.author !== "user") {
     return void 0;
   }
-  const fnCallId = getFunctionResponseCallId(candidate);
-  if (!fnCallId) {
+  const fnCallIds = (_b = (_a = candidate.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.map((part) => {
+    var _a2;
+    return (_a2 = part.functionResponse) == null ? void 0 : _a2.id;
+  }).filter((id) => !!id);
+  if (!(fnCallIds == null ? void 0 : fnCallIds.length)) {
     return void 0;
   }
   for (let i = index - 1; i >= 0; i--) {
     const request = events[i];
-    if (!isFunctionCallEvent(request, fnCallId)) {
+    if (request.author !== agentName || !fnCallIds.some((callId) => isFunctionCallEvent(request, callId))) {
       continue;
     }
     const metadata = request.customMetadata || {};

package/dist/esm/a2a/agent_card.js

@@ -10,14 +10,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 import { DefaultAgentCardResolver } from "@a2a-js/sdk/client";
 import * as fs from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-import {
-  InvocationContext
-} from "../agents/invocation_context.js";
 import { isLlmAgent } from "../agents/llm_agent.js";
 import { isLoopAgent } from "../agents/loop_agent.js";
 import { isParallelAgent } from "../agents/parallel_agent.js";
-import { ReadonlyContext } from "../agents/readonly_context.js";
 import { isSequentialAgent } from "../agents/sequential_agent.js";
+import { propagateTraceContext } from "../telemetry/api/instrumentation.js";
 import { isBaseTool } from "../tools/base_tool.js";
 import { isBaseToolset } from "../tools/base_toolset.js";
 import { logger } from "../utils/logger.js";
@@ -36,7 +33,7 @@ async function resolveAgentCard(agentCard, options = {}) {
   if (source.startsWith("http://") || source.startsWith("https://")) {
     await refuseLinkLocalHost(source);
     const resolver = new DefaultAgentCardResolver({
-      fetchImpl: refuseRedirectFetch
+      fetchImpl: tracePropagatingRefuseRedirectFetch
     });
     const card = await resolver.resolve(source);
     validateCardRpcTargets(card, source, options);
@@ -76,6 +73,7 @@ async function refuseRedirectFetch(url, init) {
   return response;
 }
 __name(refuseRedirectFetch, "refuseRedirectFetch");
+const tracePropagatingRefuseRedirectFetch = propagateTraceContext(refuseRedirectFetch);
 function parseCardUrl(source) {
   let url;
   try {
@@ -242,7 +240,7 @@ async function buildLLMAgentSkills(agent) {
     {
       id: agent.name,
       name: "model",
-      description: await buildDescriptionFromInstructions(agent),
+      description: buildAgentDescription(agent),
       tags: ["llm"]
     }
   ];
@@ -311,7 +309,7 @@ function buildAgentDescription(agent) {
   if (agent.description) {
     descriptionParts.push(agent.description);
   }
-  if (agent.subAgents.length > 0) {
+  if (!isLlmAgent(agent) && agent.subAgents.length > 0) {
     if (isLoopAgent(agent)) {
       descriptionParts.push(buildLoopAgentDescription(agent));
     } else if (isParallelAgent(agent)) {
@@ -389,82 +387,6 @@ function buildLoopAgentDescription(agent) {
   return `${descriptions.join(" ")} in a loop (max ${maxIterations} iterations).`;
 }
 __name(buildLoopAgentDescription, "buildLoopAgentDescription");
-async function buildDescriptionFromInstructions(agent) {
-  const descriptionParts = [];
-  if (agent.description) {
-    descriptionParts.push(agent.description);
-  }
-  if (agent.instruction) {
-    let instructionStr;
-    if (typeof agent.instruction === "function") {
-      const dummyContext = new ReadonlyContext(
-        new InvocationContext({
-          agent
-        })
-      );
-      try {
-        instructionStr = await agent.instruction(dummyContext);
-      } catch (e) {
-        logger.warn("Failed to resolve dynamic instruction for AgentCard", e);
-        instructionStr = "";
-      }
-    } else {
-      instructionStr = agent.instruction;
-    }
-    if (instructionStr) {
-      descriptionParts.push(replacePronouns(instructionStr));
-    }
-  }
-  const root = agent.rootAgent;
-  if (isLlmAgent(root) && root.globalInstruction) {
-    let globalInstructionStr;
-    if (typeof root.globalInstruction === "function") {
-      const dummyContext = new ReadonlyContext(
-        new InvocationContext({
-          agent
-        })
-      );
-      try {
-        globalInstructionStr = await root.globalInstruction(dummyContext);
-      } catch (e) {
-        logger.warn(
-          "Failed to resolve dynamic global instruction for AgentCard",
-          e
-        );
-        globalInstructionStr = "";
-      }
-    } else {
-      globalInstructionStr = root.globalInstruction;
-    }
-    if (globalInstructionStr) {
-      descriptionParts.push(replacePronouns(globalInstructionStr));
-    }
-  }
-  if (descriptionParts.length > 0) {
-    return descriptionParts.join(" ");
-  } else {
-    return getDefaultAgentDescription(agent);
-  }
-}
-__name(buildDescriptionFromInstructions, "buildDescriptionFromInstructions");
-function replacePronouns(instruction) {
-  const substitutions = [
-    { original: "you were", target: "I was" },
-    { original: "you are", target: "I am" },
-    { original: "you're", target: "I am" },
-    { original: "you've", target: "I have" },
-    { original: "yours", target: "mine" },
-    { original: "your", target: "my" },
-    { original: "you", target: "I" }
-  ];
-  let result = instruction;
-  for (const sub of substitutions) {
-    const pattern = new RegExp(`\\b${sub.original}\\b`, "gi");
-    result = result.replace(pattern, sub.target);
-  }
-  return result;
-}
-__name(replacePronouns, "replacePronouns");
 function getDefaultAgentDescription(agent) {
   if (isLoopAgent(agent)) {
     return "A loop workflow agent";

package/dist/esm/a2a/agent_to_a2a.js

@@ -32,6 +32,7 @@ import { AGENT_CARD_PATH } from "@a2a-js/sdk";
 import { InMemoryTaskStore } from "@a2a-js/sdk/server";
 import { StreamingMode } from "../agents/run_config.js";
 import { InMemorySessionService } from "../sessions/in_memory_session_service.js";
+import { runWithRemoteTraceContext } from "../telemetry/api/instrumentation.js";
 import { logger } from "../utils/logger.js";
 import { loadOptionalPeer } from "../utils/optional_peer.js";
 import {
@@ -52,6 +53,10 @@ async function loadExpressBindings() {
   return { express: expressModule.default, a2aExpress };
 }
 __name(loadExpressBindings, "loadExpressBindings");
+function continueRemoteTrace(req, _res, next) {
+  runWithRemoteTraceContext(req.headers, () => next());
+}
+__name(continueRemoteTrace, "continueRemoteTrace");
 function resolveA2aUserBuilder(options, a2aExpress) {
   if (options.authentication) {
     return options.authentication;
@@ -113,6 +118,7 @@ async function toA2a(agent, options = {}) {
   );
   app.use(
     `${basePath}/rest`,
+    continueRemoteTrace,
     a2aExpress.restHandler({
       requestHandler,
       userBuilder
@@ -120,6 +126,7 @@ async function toA2a(agent, options = {}) {
   );
   app.use(
     `${basePath}/jsonrpc`,
+    continueRemoteTrace,
     a2aExpress.jsonRpcHandler({
       requestHandler,
       userBuilder

package/dist/esm/a2a/event_converter_utils.js

@@ -69,7 +69,12 @@ function messageToAdkEvent(msg, invocationId, agentName, branch) {
   return {
     ...createAdkEventFromMetadata(msg),
     invocationId,
-    author: msg.role === MessageRole.USER ? MessageRole.USER : agentName,
+    // The role on a peer's message is the peer's own claim and must not decide
+    // authorship: letting `user` through here lets a remote agent post events
+    // that read as the local user's, which is a trust anchor elsewhere (tool
+    // confirmations are approved only from user-authored events). Attribute the
+    // event to the peer, the same way the task and status converters below do.
+    author: agentName,
     branch,
     content,
     turnComplete: true,
@@ -184,8 +189,10 @@ function createAdkEventFromMetadata(a2aEvent) {
     // (set it to a shared ancestor branch, or omit it) to leak its content
     // into an unrelated sibling agent's LLM context. Every caller of the
     // `*ToAdkEvent` functions in this file force-sets `branch` from its own
-    // local `InvocationContext` instead, the same way `author` is handled.
-    author: metadata[A2AMetadataKeys.AUTHOR],
+    // local `InvocationContext` instead, the same way `author` is handled:
+    // `author` is likewise never restored from peer metadata here, since every
+    // converter sets it from the local context after the spread, so reading it
+    // from metadata would be dead and read as if a peer could set the author.
     partial: metadata[A2AMetadataKeys.PARTIAL],
     errorCode: metadata[A2AMetadataKeys.ERROR_CODE],
     errorMessage: metadata[A2AMetadataKeys.ERROR_MESSAGE],