@google/adk 2.0.0 → 2.2.0

package/dist/cjs/a2a/a2a_event.js

@@ -27,7 +27,6 @@ var a2a_event_exports = {};
 __export(a2a_event_exports, {
   MessageRole: () => MessageRole,
   TaskState: () => TaskState,
-  createInputMissingErrorEvent: () => createInputMissingErrorEvent,
   createTask: () => createTask,
   createTaskArtifactUpdateEvent: () => createTaskArtifactUpdateEvent,
   createTaskCompletedEvent: () => createTaskCompletedEvent,
@@ -284,38 +283,10 @@ function createTaskInputRequiredEvent({
   };
 }
 __name(createTaskInputRequiredEvent, "createTaskInputRequiredEvent");
-function createInputMissingErrorEvent({
-  taskId,
-  contextId,
-  parts,
-  metadata
-}) {
-  return {
-    kind: "status-update",
-    taskId,
-    contextId,
-    final: true,
-    status: {
-      state: "input-required" /* INPUT_REQUIRED */,
-      message: {
-        kind: "message",
-        messageId: (0, import_env_aware_utils.randomUUID)(),
-        role: "agent",
-        taskId,
-        contextId,
-        parts
-      },
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    },
-    metadata
-  };
-}
-__name(createInputMissingErrorEvent, "createInputMissingErrorEvent");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MessageRole,
   TaskState,
-  createInputMissingErrorEvent,
   createTask,
   createTaskArtifactUpdateEvent,
   createTaskCompletedEvent,

package/dist/cjs/a2a/a2a_remote_agent.js

@@ -41,7 +41,6 @@ var import_a2a_remote_agent_utils = require("./a2a_remote_agent_utils.js");
 var import_agent_card = require("./agent_card.js");
 var import_event_converter_utils = require("./event_converter_utils.js");
 var import_metadata_converter_utils = require("./metadata_converter_utils.js");
-var import_part_converter_utils = require("./part_converter_utils.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -89,9 +88,11 @@ const _RemoteA2AAgent = class _RemoteA2AAgent extends import_base_agent.BaseAgen
       let contextId = void 0;
       if (userFnCall) {
         const event = userFnCall.response;
-        parts = (0, import_part_converter_utils.toA2AParts)(
-          ((_a = event.content) == null ? void 0 : _a.parts) || [],
-          event.longRunningToolIds
+        const peerRequestedIds = (0, import_a2a_remote_agent_utils.peerRequestedCallIds)(events, this.name);
+        parts = (0, import_a2a_remote_agent_utils.toForwardableA2AParts)(
+          event.content,
+          event.longRunningToolIds,
+          peerRequestedIds
         );
         taskId = userFnCall.taskId;
         contextId = userFnCall.contextId;
@@ -113,9 +114,11 @@ const _RemoteA2AAgent = class _RemoteA2AAgent extends import_base_agent.BaseAgen
       };
       if (taskId) message.taskId = taskId;
       if (contextId) message.contextId = contextId;
+      const metadata = (_a = this.a2aConfig.metadata) != null ? _a : context.a2aMetadata;
       const params = {
         message,
-        configuration: this.a2aConfig.messageSendConfig
+        configuration: this.a2aConfig.messageSendConfig,
+        ...metadata ? { metadata } : {}
       };
       const processor = new import_a2a_remote_agent_run_processor.A2ARemoteAgentRunProcessor(params);
       if (this.a2aConfig.beforeRequestCallbacks) {

package/dist/cjs/a2a/a2a_remote_agent_utils.js

@@ -28,12 +28,17 @@ __export(a2a_remote_agent_utils_exports, {
   getFunctionResponseCallId: () => getFunctionResponseCallId,
   getUserFunctionCallAt: () => getUserFunctionCallAt,
   isFunctionCallEvent: () => isFunctionCallEvent,
+  peerRequestedCallIds: () => peerRequestedCallIds,
   presentAsUserMessage: () => presentAsUserMessage,
+  toForwardableA2AParts: () => toForwardableA2AParts,
   toMissingRemoteSessionParts: () => toMissingRemoteSessionParts
 });
 module.exports = __toCommonJS(a2a_remote_agent_utils_exports);
+var import_functions = require("../agents/functions.js");
 var import_invocation_context = require("../agents/invocation_context.js");
 var import_event = require("../events/event.js");
+var import_case_utils = require("../utils/case_utils.js");
+var import_logger = require("../utils/logger.js");
 var import_metadata_converter_utils = require("./metadata_converter_utils.js");
 var import_part_converter_utils = require("./part_converter_utils.js");
 /**
@@ -91,23 +96,118 @@ function getFunctionResponseCallId(event) {
   return (_a = responsePart == null ? void 0 : responsePart.functionResponse) == null ? void 0 : _a.id;
 }
 __name(getFunctionResponseCallId, "getFunctionResponseCallId");
+const AUTH_CONFIG_SCHEME_KEY = "authScheme";
+const AUTH_CONFIG_CREDENTIAL_KEYS = [
+  // camelCase only by design: callers normalise the payload with
+  // camelCaseKeys() before these keys are looked up, so the snake_case
+  // spellings (raw_auth_credential, exchanged_auth_credential) are covered.
+  "rawAuthCredential",
+  "exchangedAuthCredential"
+];
+function payloadIsAuthConfig(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return false;
+  }
+  const keys = new Set(Object.keys(payload));
+  if (!keys.has(AUTH_CONFIG_SCHEME_KEY)) {
+    return false;
+  }
+  return AUTH_CONFIG_CREDENTIAL_KEYS.some((key) => keys.has(key));
+}
+__name(payloadIsAuthConfig, "payloadIsAuthConfig");
+function isCredentialFunctionCall(functionCall) {
+  if (functionCall.name === import_functions.REQUEST_CREDENTIAL_FUNCTION_CALL_NAME) {
+    return true;
+  }
+  const args = (0, import_case_utils.camelCaseKeys)(functionCall.args);
+  if (!args || typeof args !== "object") {
+    return false;
+  }
+  const authConfig = args["authConfig"];
+  return payloadIsAuthConfig(authConfig);
+}
+__name(isCredentialFunctionCall, "isCredentialFunctionCall");
+function isCredentialFunctionResponse(functionResponse) {
+  if (functionResponse.name === import_functions.REQUEST_CREDENTIAL_FUNCTION_CALL_NAME) {
+    return true;
+  }
+  return payloadIsAuthConfig((0, import_case_utils.camelCaseKeys)(functionResponse.response));
+}
+__name(isCredentialFunctionResponse, "isCredentialFunctionResponse");
+function peerRequestedCallIds(events, peerName) {
+  var _a, _b, _c;
+  const peer = /* @__PURE__ */ new Set();
+  const local = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    for (const part of (_b = (_a = event.content) == null ? void 0 : _a.parts) != null ? _b : []) {
+      const id = (_c = part.functionCall) == null ? void 0 : _c.id;
+      if (!id) {
+        continue;
+      }
+      (event.author === peerName ? peer : local).add(id);
+    }
+  }
+  return new Set([...peer].filter((id) => !local.has(id)));
+}
+__name(peerRequestedCallIds, "peerRequestedCallIds");
+function withoutCredentialParts(content, peerRequestedIds) {
+  if (!content || !content.parts) {
+    return content;
+  }
+  const isDroppedCredentialPart = /* @__PURE__ */ __name((part) => {
+    if (part.functionCall && isCredentialFunctionCall(part.functionCall)) {
+      return true;
+    }
+    if (part.functionResponse && isCredentialFunctionResponse(part.functionResponse)) {
+      const id = part.functionResponse.id;
+      return !(id && peerRequestedIds.has(id));
+    }
+    return false;
+  }, "isDroppedCredentialPart");
+  const parts = content.parts.filter((part) => !isDroppedCredentialPart(part));
+  if (parts.length === content.parts.length) {
+    return content;
+  }
+  import_logger.logger.warn(
+    `Dropped ${content.parts.length - parts.length} credential-bearing part(s) before forwarding to the remote peer -- it did not request them.`
+  );
+  return { ...content, parts };
+}
+__name(withoutCredentialParts, "withoutCredentialParts");
+function toForwardableA2AParts(content, longRunningToolIds, peerRequestedIds) {
+  const scrubbed = withoutCredentialParts(content, peerRequestedIds);
+  if (!(scrubbed == null ? void 0 : scrubbed.parts)) {
+    return [];
+  }
+  return (0, import_part_converter_utils.toA2AParts)(scrubbed.parts, longRunningToolIds);
+}
+__name(toForwardableA2AParts, "toForwardableA2AParts");
 function toMissingRemoteSessionParts(ctx, session) {
   const events = session.events;
+  const peerName = (0, import_invocation_context.requireAgent)(ctx).name;
   let contextId = void 0;
   let lastRemoteResponseIndex = -1;
   for (let i = events.length - 1; i >= 0; i--) {
     const event = events[i];
-    if (event.author === (0, import_invocation_context.requireAgent)(ctx).name) {
+    if (event.author === peerName) {
       lastRemoteResponseIndex = i;
       const metadata = event.customMetadata || {};
       contextId = metadata[import_metadata_converter_utils.AdkMetadataKeys.CONTEXT_ID];
       break;
     }
   }
+  const peerRequestedIds = peerRequestedCallIds(events, peerName);
   const missingParts = [];
   for (let i = lastRemoteResponseIndex + 1; i < events.length; i++) {
     let event = events[i];
-    if (event.author !== "user" && event.author !== (0, import_invocation_context.requireAgent)(ctx).name) {
+    const scrubbedContent = withoutCredentialParts(
+      event.content,
+      peerRequestedIds
+    );
+    if (scrubbedContent !== event.content) {
+      event = { ...event, content: scrubbedContent };
+    }
+    if (event.author !== "user" && event.author !== peerName) {
       event = presentAsUserMessage(ctx, event);
     }
     if (!event.content || !event.content.parts || event.content.parts.length === 0) {
@@ -167,6 +267,8 @@ __name(presentAsUserMessage, "presentAsUserMessage");
   getFunctionResponseCallId,
   getUserFunctionCallAt,
   isFunctionCallEvent,
+  peerRequestedCallIds,
   presentAsUserMessage,
+  toForwardableA2AParts,
   toMissingRemoteSessionParts
 });

package/dist/cjs/a2a/agent_card.js

@@ -42,6 +42,7 @@ __export(agent_card_exports, {
 module.exports = __toCommonJS(agent_card_exports);
 var import_client = require("@a2a-js/sdk/client");
 var fs = __toESM(require("node:fs/promises"), 1);
+var import_node_url = require("node:url");
 var import_invocation_context = require("../agents/invocation_context.js");
 var import_llm_agent = require("../agents/llm_agent.js");
 var import_loop_agent = require("../agents/loop_agent.js");
@@ -51,23 +52,48 @@ var import_sequential_agent = require("../agents/sequential_agent.js");
 var import_base_tool = require("../tools/base_tool.js");
 var import_base_toolset = require("../tools/base_toolset.js");
 var import_logger = require("../utils/logger.js");
+var import_ssrf_guard = require("../utils/ssrf_guard.js");
 var import_workflow = require("../workflow/workflow.js");
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+const WINDOWS_DRIVE_PROTOCOL = /^[a-z]:$/i;
 async function resolveAgentCard(agentCard) {
   if (typeof agentCard === "object") {
     return agentCard;
   }
-  const source = agentCard;
-  if (source.startsWith("http://") || source.startsWith("https://")) {
-    const resolver = new import_client.DefaultAgentCardResolver();
-    return await resolver.resolve(source);
+  const url = parseCardUrl(agentCard);
+  if (url && (0, import_ssrf_guard.isHttpUrl)(url)) {
+    await assertHostAllowed(url);
+    const resolver = new import_client.DefaultAgentCardResolver({
+      fetchImpl: noRedirectFetch(agentCard)
+    });
+    return resolver.resolve(agentCard);
+  }
+  if (url && url.protocol !== "file:") {
+    throw new Error(
+      `Unsupported agent card URL scheme "${url.protocol}": ${agentCard}. Use http://, https:// or file://, or pass a filesystem path with no scheme.`
+    );
   }
+  return readAgentCardFile(agentCard, url);
+}
+__name(resolveAgentCard, "resolveAgentCard");
+function parseCardUrl(source) {
+  let url;
   try {
-    const content = await fs.readFile(source, "utf-8");
+    url = new URL(source);
+  } catch {
+    return null;
+  }
+  return WINDOWS_DRIVE_PROTOCOL.test(url.protocol) ? null : url;
+}
+__name(parseCardUrl, "parseCardUrl");
+async function readAgentCardFile(source, url) {
+  try {
+    const path = url ? (0, import_node_url.fileURLToPath)(url) : source;
+    const content = await fs.readFile(path, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     throw new Error(
@@ -75,7 +101,33 @@ async function resolveAgentCard(agentCard) {
     );
   }
 }
-__name(resolveAgentCard, "resolveAgentCard");
+__name(readAgentCardFile, "readAgentCardFile");
+function noRedirectFetch(source) {
+  return async (input, init) => {
+    const response = await fetch(input, { ...init, redirect: "manual" });
+    if (isRedirect(response.status)) {
+      throw new Error(
+        `Refusing to follow a redirect while fetching the agent card from ${source} (status ${response.status}, location ${response.headers.get("location")}). Configure the final URL instead.`
+      );
+    }
+    return response;
+  };
+}
+__name(noRedirectFetch, "noRedirectFetch");
+function isRedirect(status) {
+  return status === 0 || status >= 300 && status < 400;
+}
+__name(isRedirect, "isRedirect");
+async function assertHostAllowed(url) {
+  const host = (0, import_ssrf_guard.normalizeHost)(url.hostname);
+  const addresses = await (0, import_ssrf_guard.resolveHostAddresses)(host);
+  if (addresses.some(import_ssrf_guard.isLinkLocalAddress)) {
+    throw new Error(
+      `Refusing to fetch agent card from a link-local address: ${host}`
+    );
+  }
+}
+__name(assertHostAllowed, "assertHostAllowed");
 async function getA2AAgentCard(agent, transports) {
   return {
     name: agent.name,
@@ -161,6 +213,14 @@ async function buildLLMAgentSkills(agent) {
       }
     }
   }
+  if (agent.codeExecutor) {
+    skills.push({
+      id: `${agent.name}-code-executor`,
+      name: "code-execution",
+      description: "Can execute code",
+      tags: ["llm", "code_execution"]
+    });
+  }
   return skills;
 }
 __name(buildLLMAgentSkills, "buildLLMAgentSkills");

package/dist/cjs/a2a/agent_executor.js

@@ -36,6 +36,7 @@ var import_event_processor_utils = require("./event_processor_utils.js");
 var import_executor_context = require("./executor_context.js");
 var import_metadata_converter_utils = require("./metadata_converter_utils.js");
 var import_part_converter_utils = require("./part_converter_utils.js");
+var import_request_metadata = require("./request_metadata.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -62,14 +63,16 @@ const _A2AAgentExecutor = class _A2AAgentExecutor {
       adkRunner.sessionService,
       adkRunner.appName
     );
+    const a2aMetadata = (0, import_request_metadata.getA2aRequestMetadata)(ctx);
     const executorContext = (0, import_executor_context.createExecutorContext)({
       session,
       userContent: genAIUserMessage,
-      requestContext: ctx
+      requestContext: ctx,
+      a2aMetadata
     });
     try {
       if (this.config.beforeExecuteCallback) {
-        await this.config.beforeExecuteCallback(ctx);
+        await this.config.beforeExecuteCallback(ctx, a2aMetadata);
       }
       const unansweredRequestEvent = (0, import_event_processor_utils.getUnansweredRequestEvent)({
         taskId: ctx.taskId,
@@ -82,7 +85,10 @@ const _A2AAgentExecutor = class _A2AAgentExecutor {
         await this.publishFinalTaskStatus({
           executorContext,
           eventBus,
-          event: unansweredRequestEvent
+          event: {
+            ...unansweredRequestEvent,
+            metadata: (0, import_metadata_converter_utils.getA2ASessionMetadata)(executorContext)
+          }
         });
         return;
       }
@@ -91,14 +97,16 @@ const _A2AAgentExecutor = class _A2AAgentExecutor {
           (0, import_a2a_event.createTask)({
             taskId: ctx.taskId,
             contextId: ctx.contextId,
-            message: a2aUserMessage
+            message: a2aUserMessage,
+            metadata: (0, import_metadata_converter_utils.getA2ASessionMetadata)(executorContext)
           })
         );
       }
       eventBus.publish(
         (0, import_a2a_event.createTaskWorkingEvent)({
           taskId: ctx.taskId,
-          contextId: ctx.contextId
+          contextId: ctx.contextId,
+          metadata: (0, import_metadata_converter_utils.getA2ASessionMetadata)(executorContext)
         })
       );
       const adkEvents = [];
@@ -109,7 +117,11 @@ const _A2AAgentExecutor = class _A2AAgentExecutor {
         // Marked remote so the run knows this message came from a peer rather
         // than from the operator: a human-in-the-loop gate is not answerable
         // over A2A unless the deployment opts in.
-        runConfig: { ...this.config.runConfig, remoteDelivered: true }
+        runConfig: {
+          ...this.config.runConfig,
+          remoteDelivered: true,
+          ...a2aMetadata ? { a2aMetadata } : {}
+        }
       })) {
         adkEvents.push(adkEvent);
         const a2aEvent = this.convertAdkEventToA2AEvent(

package/dist/cjs/a2a/agent_to_a2a.js

@@ -35,6 +35,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var agent_to_a2a_exports = {};
 __export(agent_to_a2a_exports, {
+  AdkDefaultRequestHandler: () => import_request_metadata.AdkDefaultRequestHandler,
+  getA2aRequestMetadata: () => import_request_metadata.getA2aRequestMetadata,
   toA2a: () => toA2a
 });
 module.exports = __toCommonJS(agent_to_a2a_exports);
@@ -46,6 +48,7 @@ var import_logger = require("../utils/logger.js");
 var import_optional_peer = require("../utils/optional_peer.js");
 var import_agent_card = require("./agent_card.js");
 var import_agent_executor = require("./agent_executor.js");
+var import_request_metadata = require("./request_metadata.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -106,7 +109,7 @@ async function toA2a(agent, options = {}) {
       streamingMode: import_run_config.StreamingMode.SSE
     }
   });
-  const requestHandler = new import_server.DefaultRequestHandler(
+  const requestHandler = new import_request_metadata.AdkDefaultRequestHandler(
     agentCard,
     new import_server.InMemoryTaskStore(),
     agentExecutor
@@ -138,5 +141,7 @@ async function toA2a(agent, options = {}) {
 __name(toA2a, "toA2a");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AdkDefaultRequestHandler,
+  getA2aRequestMetadata,
   toA2a
 });

package/dist/cjs/a2a/event_processor_utils.js

@@ -152,7 +152,7 @@ function getUnansweredRequestEvent(options) {
   if (!missingId) {
     return void 0;
   }
-  return (0, import_a2a_event.createInputMissingErrorEvent)({
+  return (0, import_a2a_event.createTaskInputRequiredEvent)({
     taskId: (_b = task == null ? void 0 : task.id) != null ? _b : taskId,
     contextId: (_c = task == null ? void 0 : task.contextId) != null ? _c : contextId,
     parts: [

package/dist/cjs/a2a/executor_context.js

@@ -36,7 +36,8 @@ module.exports = __toCommonJS(executor_context_exports);
 function createExecutorContext({
   session,
   userContent,
-  requestContext
+  requestContext,
+  a2aMetadata
 }) {
   return {
     userId: session.userId,
@@ -45,7 +46,8 @@ function createExecutorContext({
     readonlyState: session.state,
     events: session.events,
     userContent,
-    requestContext
+    requestContext,
+    a2aMetadata
   };
 }
 __name(createExecutorContext, "createExecutorContext");

package/dist/cjs/a2a/index.js

@@ -26,9 +26,11 @@ var a2a_exports = {};
 __export(a2a_exports, {
   A2AAgentExecutor: () => import_agent_executor.A2AAgentExecutor,
   AGENT_CARD_PATH: () => import_a2a_remote_agent.AGENT_CARD_PATH,
+  AdkDefaultRequestHandler: () => import_agent_to_a2a.AdkDefaultRequestHandler,
   RemoteA2AAgent: () => import_a2a_remote_agent.RemoteA2AAgent,
   bearerTokenUserBuilder: () => import_auth.bearerTokenUserBuilder,
   getA2AAgentCard: () => import_agent_card.getA2AAgentCard,
+  getA2aRequestMetadata: () => import_agent_to_a2a.getA2aRequestMetadata,
   toA2a: () => import_agent_to_a2a.toA2a
 });
 module.exports = __toCommonJS(a2a_exports);
@@ -46,8 +48,10 @@ var import_auth = require("./auth.js");
 0 && (module.exports = {
   A2AAgentExecutor,
   AGENT_CARD_PATH,
+  AdkDefaultRequestHandler,
   RemoteA2AAgent,
   bearerTokenUserBuilder,
   getA2AAgentCard,
+  getA2aRequestMetadata,
   toA2a
 });

package/dist/cjs/a2a/request_metadata.js

@@ -0,0 +1,94 @@
+/**
+  * @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 request_metadata_exports = {};
+__export(request_metadata_exports, {
+  AdkDefaultRequestHandler: () => AdkDefaultRequestHandler,
+  getA2aRequestMetadata: () => getA2aRequestMetadata
+});
+module.exports = __toCommonJS(request_metadata_exports);
+var import_server = require("@a2a-js/sdk/server");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const requestMetadataStore = /* @__PURE__ */ new Map();
+function getA2aRequestMetadata(ctx) {
+  var _a, _b;
+  const reqContext = ctx;
+  if ((_a = reqContext.request) == null ? void 0 : _a.metadata) {
+    return reqContext.request.metadata;
+  }
+  const messageId = (_b = ctx.userMessage) == null ? void 0 : _b.messageId;
+  if (messageId && requestMetadataStore.has(messageId)) {
+    return requestMetadataStore.get(messageId);
+  }
+  return void 0;
+}
+__name(getA2aRequestMetadata, "getA2aRequestMetadata");
+const _AdkDefaultRequestHandler = class _AdkDefaultRequestHandler extends import_server.DefaultRequestHandler {
+  async sendMessage(params, context) {
+    var _a;
+    const messageId = (_a = params.message) == null ? void 0 : _a.messageId;
+    if (messageId && params.metadata) {
+      requestMetadataStore.set(
+        messageId,
+        params.metadata
+      );
+    }
+    try {
+      return await super.sendMessage(params, context);
+    } finally {
+      if (messageId) {
+        requestMetadataStore.delete(messageId);
+      }
+    }
+  }
+  async *sendMessageStream(params, context) {
+    var _a;
+    const messageId = (_a = params.message) == null ? void 0 : _a.messageId;
+    if (messageId && params.metadata) {
+      requestMetadataStore.set(
+        messageId,
+        params.metadata
+      );
+    }
+    try {
+      yield* super.sendMessageStream(params, context);
+    } finally {
+      if (messageId) {
+        requestMetadataStore.delete(messageId);
+      }
+    }
+  }
+};
+__name(_AdkDefaultRequestHandler, "AdkDefaultRequestHandler");
+let AdkDefaultRequestHandler = _AdkDefaultRequestHandler;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdkDefaultRequestHandler,
+  getA2aRequestMetadata
+});

package/dist/cjs/agents/base_agent.js

@@ -42,7 +42,7 @@ var import_invocation_context = require("./invocation_context.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a, _b;
-const BASE_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseAgent");
+const BASE_AGENT_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.baseAgent");
 function isBaseAgent(obj) {
   return typeof obj === "object" && obj !== null && BASE_AGENT_SIGNATURE_SYMBOL in obj && obj[BASE_AGENT_SIGNATURE_SYMBOL] === true;
 }
@@ -78,15 +78,16 @@ const _BaseAgent = class _BaseAgent extends (_b = import_base_node.BaseNode, _a
   /**
    * Creates a copy of this agent with the given config fields overridden.
    *
-   * Mirrors adk-python's `BaseAgent.clone(update=...)`. The clone is a detached
-   * root: its `parentAgent` is always `undefined`. Sub-agents are recursively
-   * cloned (and re-parented to the clone) unless `subAgents` is overridden.
-   * Rebuilding via the concrete constructor re-derives all state, so a cloned
-   * `LlmAgent` gets a fresh `requestProcessors` array rather than sharing the
-   * original's. See google/adk-js#534.
+   * The clone is a detached root: its `parentAgent` is always `undefined`.
+   * Sub-agents are recursively cloned (and re-parented to the clone) unless
+   * `subAgents` is overridden. Rebuilding via the concrete constructor
+   * re-derives all state, so a cloned `LlmAgent` gets a fresh
+   * `requestProcessors` array rather than sharing the original's.
+   * See google/adk-js#534.
    *
    * @param overrides Config fields to override on the clone. Overriding
-   *     `parentAgent` is rejected, matching adk-python.
+   *     `parentAgent` is rejected: parentage is assigned only when a parent
+   *     agent is constructed with its sub-agents.
    * @returns A new detached agent instance of the same concrete class.
    */
   clone(overrides) {

package/dist/cjs/agents/context.js

@@ -50,8 +50,14 @@ const _Context = class _Context extends import_readonly_context.ReadonlyContext
    *     call.
    * @param options.toolConfirmation The tool confirmation of the current tool
    *     call.
+   * @param options.resumeInputs The inputs the current tool call is being
+   *     resumed with, if it paused to ask for them, keyed by interrupt id.
+   *     Defaults to empty rather than absent, matching adk-python's
+   *     `Context.resume_inputs`. Carries no approval; see
+   *     {@link ResumeInputs}.
    */
   constructor(options) {
+    var _a;
     super(options.invocationContext);
     this.eventActions = options.eventActions || (0, import_event_actions.createEventActions)();
     this._state = new import_state.State(
@@ -60,6 +66,7 @@ const _Context = class _Context extends import_readonly_context.ReadonlyContext
     );
     this.functionCallId = options.functionCallId;
     this.toolConfirmation = options.toolConfirmation;
+    this.resumeInputs = (_a = options.resumeInputs) != null ? _a : {};
     this.abortSignal = options.invocationContext.abortSignal;
   }
   /**