@google/adk 2.0.0 → 2.1.0

package/dist/cjs/agents/functions.js

@@ -35,9 +35,11 @@ __export(functions_exports, {
   generateAuthEvent: () => generateAuthEvent,
   generateClientFunctionCallId: () => import_event2.generateClientFunctionCallId,
   generateRequestConfirmationEvent: () => generateRequestConfirmationEvent,
+  getConflictingFunctionResponseAuthors: () => getConflictingFunctionResponseAuthors,
   getLongRunningFunctionCalls: () => getLongRunningFunctionCalls,
   handleFunctionCallList: () => handleFunctionCallList,
   handleFunctionCallsAsync: () => handleFunctionCallsAsync,
+  isToolNotFound: () => isToolNotFound,
   mergeParallelFunctionResponseEvents: () => mergeParallelFunctionResponseEvents,
   populateClientFunctionCallId: () => import_event2.populateClientFunctionCallId,
   reservedFunctionCallName: () => import_framework_function_calls2.reservedFunctionCallName
@@ -47,6 +49,7 @@ var import_genai = require("@google/genai");
 var import_lodash_es = require("lodash-es");
 var import_event = require("../events/event.js");
 var import_event_actions = require("../events/event_actions.js");
+var import_base_tool = require("../tools/base_tool.js");
 var import_logger = require("../utils/logger.js");
 var import_context = require("./context.js");
 var import_framework_function_calls = require("./framework_function_calls.js");
@@ -58,9 +61,10 @@ var import_framework_function_calls2 = require("./framework_function_calls.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a, _b;
 function toolEventAuthor(invocationContext) {
-  var _a, _b;
-  return (_b = (_a = invocationContext.agent) == null ? void 0 : _a.name) != null ? _b : "";
+  var _a2, _b2;
+  return (_b2 = (_a2 = invocationContext.agent) == null ? void 0 : _a2.name) != null ? _b2 : "";
 }
 __name(toolEventAuthor, "toolEventAuthor");
 const functionsExportedForTestingOnly = {
@@ -79,8 +83,8 @@ function getLongRunningFunctionCalls(functionCalls, toolsDict) {
 }
 __name(getLongRunningFunctionCalls, "getLongRunningFunctionCalls");
 function generateAuthEvent(invocationContext, functionResponseEvent) {
-  var _a;
-  if (!((_a = functionResponseEvent.actions) == null ? void 0 : _a.requestedAuthConfigs) || (0, import_lodash_es.isEmpty)(functionResponseEvent.actions.requestedAuthConfigs)) {
+  var _a2, _b2, _c;
+  if (!((_a2 = functionResponseEvent.actions) == null ? void 0 : _a2.requestedAuthConfigs) || (0, import_lodash_es.isEmpty)(functionResponseEvent.actions.requestedAuthConfigs)) {
     return void 0;
   }
   const parts = [];
@@ -105,7 +109,7 @@ function generateAuthEvent(invocationContext, functionResponseEvent) {
     branch: invocationContext.branch,
     content: {
       parts,
-      role: functionResponseEvent.content.role
+      role: (_c = (_b2 = functionResponseEvent.content) == null ? void 0 : _b2.role) != null ? _c : "user"
     },
     longRunningToolIds: Array.from(longRunningToolIds)
   });
@@ -116,8 +120,8 @@ function generateRequestConfirmationEvent({
   functionCallEvent,
   functionResponseEvent
 }) {
-  var _a, _b;
-  if (!((_a = functionResponseEvent.actions) == null ? void 0 : _a.requestedToolConfirmations) || (0, import_lodash_es.isEmpty)(functionResponseEvent.actions.requestedToolConfirmations)) {
+  var _a2, _b2, _c, _d;
+  if (!((_a2 = functionResponseEvent.actions) == null ? void 0 : _a2.requestedToolConfirmations) || (0, import_lodash_es.isEmpty)(functionResponseEvent.actions.requestedToolConfirmations)) {
     return;
   }
   const parts = [];
@@ -126,7 +130,7 @@ function generateRequestConfirmationEvent({
   for (const [functionCallId, toolConfirmation] of Object.entries(
     functionResponseEvent.actions.requestedToolConfirmations
   )) {
-    const originalFunctionCall = (_b = functionCalls.find((call) => call.id === functionCallId)) != null ? _b : void 0;
+    const originalFunctionCall = (_b2 = functionCalls.find((call) => call.id === functionCallId)) != null ? _b2 : void 0;
     if (!originalFunctionCall) {
       continue;
     }
@@ -147,7 +151,7 @@ function generateRequestConfirmationEvent({
     branch: invocationContext.branch,
     content: {
       parts,
-      role: functionResponseEvent.content.role
+      role: (_d = (_c = functionResponseEvent.content) == null ? void 0 : _c.role) != null ? _d : "user"
     },
     actions: functionResponseEvent.actions,
     longRunningToolIds: Array.from(longRunningToolIds)
@@ -212,7 +216,8 @@ async function handleFunctionCallsAsync({
   beforeToolCallbacks,
   afterToolCallbacks,
   filters,
-  toolConfirmationDict
+  toolConfirmationDict,
+  resumeInputsDict
 }) {
   const functionCalls = (0, import_event.getFunctionCalls)(functionCallEvent);
   return await handleFunctionCallList({
@@ -222,7 +227,8 @@ async function handleFunctionCallsAsync({
     beforeToolCallbacks,
     afterToolCallbacks,
     filters,
-    toolConfirmationDict
+    toolConfirmationDict,
+    resumeInputsDict
   });
 }
 __name(handleFunctionCallsAsync, "handleFunctionCallsAsync");
@@ -239,6 +245,70 @@ function normalizeCallbackResponse(response) {
   return response;
 }
 __name(normalizeCallbackResponse, "normalizeCallbackResponse");
+const RESOLUTION_FAILURE_CAUSES = `Possible causes:
+  1. The model hallucinated the name.
+  2. The tool is not registered on this agent, or a plugin filtered it out of this request.
+  3. The name does not match the registered tool's name exactly.
+  4. The tool is registered but never enters the toolsDict, because its \`_getDeclaration()\` returns undefined (as prompt-injecting tools like \`ExampleTool\` and \`PreloadMemoryTool\` do).`;
+const TOOL_NOT_FOUND_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.toolNotFound");
+function isToolNotFound(tool) {
+  return typeof tool === "object" && tool !== null && tool[TOOL_NOT_FOUND_SYMBOL] === true;
+}
+__name(isToolNotFound, "isToolNotFound");
+const _ToolNotFoundPlaceholder = class _ToolNotFoundPlaceholder extends (_b = import_base_tool.BaseTool, _a = TOOL_NOT_FOUND_SYMBOL, _b) {
+  constructor(name, resolutionError) {
+    super({ name, description: "Tool not found" });
+    this.resolutionError = resolutionError;
+    this[_a] = true;
+  }
+  async runAsync() {
+    throw this.resolutionError;
+  }
+};
+__name(_ToolNotFoundPlaceholder, "ToolNotFoundPlaceholder");
+let ToolNotFoundPlaceholder = _ToolNotFoundPlaceholder;
+async function answerUnresolvableCall({
+  invocationContext,
+  functionCall,
+  toolsDict,
+  toolContext
+}) {
+  return import_tracing.tracer.startActiveSpan(
+    `execute_tool ${functionCall.name || "<unnamed>"}`,
+    async (span) => {
+      var _a2, _b2;
+      try {
+        const toolName = functionCall.name || "<unnamed>";
+        const error = new Error(
+          `Function ${toolName} is not found in the toolsDict.`
+        );
+        const tool = new ToolNotFoundPlaceholder(toolName, error);
+        const onToolErrorResponse = await invocationContext.pluginManager.runOnToolErrorCallback({
+          tool,
+          toolArgs: (_a2 = functionCall.args) != null ? _a2 : {},
+          toolContext,
+          error
+        });
+        if (onToolErrorResponse == null) {
+          const callableTools = Object.keys(toolsDict);
+          import_logger.logger.warn(
+            `Could not resolve tool '${toolName}' for function call '${(_b2 = functionCall.id) != null ? _b2 : ""}'. Callable tools: ${callableTools.length ? callableTools.join(", ") : "(none)"}.
+` + RESOLUTION_FAILURE_CAUSES
+          );
+        }
+        return buildResponseEvent(
+          tool,
+          onToolErrorResponse != null ? onToolErrorResponse : { error: error.message },
+          toolContext,
+          invocationContext
+        );
+      } finally {
+        span.end();
+      }
+    }
+  );
+}
+__name(answerUnresolvableCall, "answerUnresolvableCall");
 async function handleFunctionCallList({
   invocationContext,
   functionCalls,
@@ -246,9 +316,10 @@ async function handleFunctionCallList({
   beforeToolCallbacks,
   afterToolCallbacks,
   filters,
-  toolConfirmationDict
+  toolConfirmationDict,
+  resumeInputsDict
 }) {
-  var _a;
+  var _a2;
   const functionResponseEvents = [];
   const filteredFunctionCalls = functionCalls.filter((functionCall) => {
     return !filters || functionCall.id && filters.has(functionCall.id);
@@ -258,14 +329,30 @@ async function handleFunctionCallList({
     if (toolConfirmationDict && functionCall.id) {
       toolConfirmation = toolConfirmationDict[functionCall.id];
     }
-    const { tool, toolContext } = getToolAndContext({
+    let resumeInputs = void 0;
+    if (resumeInputsDict && functionCall.id) {
+      resumeInputs = resumeInputsDict[functionCall.id];
+    }
+    const toolContext = new import_context.Context({
       invocationContext,
-      functionCall,
-      toolsDict,
-      toolConfirmation
+      functionCallId: functionCall.id || void 0,
+      toolConfirmation,
+      resumeInputs
     });
+    const tool = functionCall.name && Object.hasOwn(toolsDict, functionCall.name) ? toolsDict[functionCall.name] : void 0;
+    if (!tool) {
+      functionResponseEvents.push(
+        await answerUnresolvableCall({
+          invocationContext,
+          functionCall,
+          toolsDict,
+          toolContext
+        })
+      );
+      continue;
+    }
     import_logger.logger.debug(`execute_tool ${tool.name}`);
-    const functionArgs = (_a = functionCall.args) != null ? _a : {};
+    const functionArgs = (_a2 = functionCall.args) != null ? _a2 : {};
     let functionResponse = null;
     let functionResponseError;
     functionResponse = await invocationContext.pluginManager.runBeforeToolCallback({
@@ -330,6 +417,16 @@ async function handleFunctionCallList({
       functionResponse = normalizeCallbackResponse(alteredFunctionResponse);
     }
     if (tool.isLongRunning && functionResponse == null) {
+      if (!(0, import_event_actions.isDefaultEventActions)(toolContext.actions)) {
+        functionResponseEvents.push(
+          (0, import_event.createEvent)({
+            invocationId: invocationContext.invocationId,
+            author: toolEventAuthor(invocationContext),
+            actions: toolContext.actions,
+            branch: invocationContext.branch
+          })
+        );
+      }
       continue;
     }
     if (functionResponseError) {
@@ -385,26 +482,6 @@ async function handleFunctionCallList({
   return mergedEvent;
 }
 __name(handleFunctionCallList, "handleFunctionCallList");
-function getToolAndContext({
-  invocationContext,
-  functionCall,
-  toolsDict,
-  toolConfirmation
-}) {
-  if (!functionCall.name || !(functionCall.name in toolsDict)) {
-    throw new Error(
-      `Function ${functionCall.name} is not found in the toolsDict.`
-    );
-  }
-  const toolContext = new import_context.Context({
-    invocationContext,
-    functionCallId: functionCall.id || void 0,
-    toolConfirmation
-  });
-  const tool = toolsDict[functionCall.name];
-  return { tool, toolContext };
-}
-__name(getToolAndContext, "getToolAndContext");
 function mergeParallelFunctionResponseEvents(functionResponseEvents) {
   if (!functionResponseEvents.length) {
     throw new Error("No function response events provided.");
@@ -446,22 +523,46 @@ function findEventByFunctionCallId(events, functionCallId, endIndex = events.len
   return void 0;
 }
 __name(findEventByFunctionCallId, "findEventByFunctionCallId");
-function findMatchingFunctionCall(events) {
+function resolveFunctionResponseMatch(events) {
+  var _a2, _b2;
   if (!events.length) {
-    return void 0;
+    return { resolved: void 0, conflictingAuthors: void 0 };
   }
   const lastEvent = events[events.length - 1];
   const functionResponses = (0, import_event.getFunctionResponses)(lastEvent);
-  if (!functionResponses.length || !functionResponses[0].id) {
-    return void 0;
+  if (!functionResponses.length) {
+    return { resolved: void 0, conflictingAuthors: void 0 };
   }
-  return findEventByFunctionCallId(
-    events,
-    functionResponses[0].id,
-    events.length - 1
-  );
+  let resolved;
+  let conflictingAuthors;
+  for (const functionResponse of functionResponses) {
+    if (!functionResponse.id) {
+      continue;
+    }
+    const match = findEventByFunctionCallId(
+      events,
+      functionResponse.id,
+      events.length - 1
+    );
+    if (!match) {
+      continue;
+    }
+    if (!conflictingAuthors && resolved && resolved.author !== match.author) {
+      conflictingAuthors = [(_a2 = resolved.author) != null ? _a2 : "", (_b2 = match.author) != null ? _b2 : ""];
+    }
+    resolved = match;
+  }
+  return { resolved, conflictingAuthors };
+}
+__name(resolveFunctionResponseMatch, "resolveFunctionResponseMatch");
+function findMatchingFunctionCall(events) {
+  return resolveFunctionResponseMatch(events).resolved;
 }
 __name(findMatchingFunctionCall, "findMatchingFunctionCall");
+function getConflictingFunctionResponseAuthors(events) {
+  return resolveFunctionResponseMatch(events).conflictingAuthors;
+}
+__name(getConflictingFunctionResponseAuthors, "getConflictingFunctionResponseAuthors");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AF_FUNCTION_CALL_ID_PREFIX,
@@ -474,9 +575,11 @@ __name(findMatchingFunctionCall, "findMatchingFunctionCall");
   generateAuthEvent,
   generateClientFunctionCallId,
   generateRequestConfirmationEvent,
+  getConflictingFunctionResponseAuthors,
   getLongRunningFunctionCalls,
   handleFunctionCallList,
   handleFunctionCallsAsync,
+  isToolNotFound,
   mergeParallelFunctionResponseEvents,
   populateClientFunctionCallId,
   reservedFunctionCallName

package/dist/cjs/agents/invocation_context.js

@@ -80,6 +80,7 @@ const _InvocationContext = class _InvocationContext {
     this.workflowInstructionScope = params.workflowInstructionScope;
     this.isolationScope = params.isolationScope;
     this.nodeToolDepth = (_a = params.nodeToolDepth) != null ? _a : 0;
+    this.a2aMetadata = params.a2aMetadata;
     this.invocationCostManager = (_b = params.invocationCostManager) != null ? _b : new InvocationCostManager();
     this.liveRequestQueue = params.liveRequestQueue;
     this.liveSessionResumptionHandle = params.liveSessionResumptionHandle;

package/dist/cjs/agents/llm_agent.js

@@ -37,6 +37,7 @@ var import_base_node = require("../workflow/base_node.js");
 var import_node_tool = require("../workflow/nodes/node_tool.js");
 var import_run_llm_agent_as_node = require("../workflow/run_llm_agent_as_node.js");
 var import_event = require("../events/event.js");
+var import_event_actions = require("../events/event_actions.js");
 var import_base_llm = require("../models/base_llm.js");
 var import_registry = require("../models/registry.js");
 var import_base_tool = require("../tools/base_tool.js");
@@ -130,7 +131,7 @@ async function convertToolUnionToTools(toolUnion, context2) {
   return await toolUnion.getTools(context2);
 }
 __name(convertToolUnionToTools, "convertToolUnionToTools");
-const LLM_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.llmAgent");
+const LLM_AGENT_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.llmAgent");
 function isLlmAgent(obj) {
   return typeof obj === "object" && obj !== null && LLM_AGENT_SIGNATURE_SYMBOL in obj && obj[LLM_AGENT_SIGNATURE_SYMBOL] === true;
 }
@@ -464,7 +465,7 @@ const _LlmAgent = class _LlmAgent extends (_b = import_base_agent.BaseAgent, _a
       if (!lastEvent) {
         break;
       }
-      const isEmptyMetadataEvent = lastEvent.author === this.name && !lastEvent.partial && (!((_b2 = lastEvent.content) == null ? void 0 : _b2.parts) || lastEvent.content.parts.length === 0);
+      const isEmptyMetadataEvent = lastEvent.author === this.name && !lastEvent.partial && (!((_b2 = lastEvent.content) == null ? void 0 : _b2.parts) || lastEvent.content.parts.length === 0) && (0, import_event_actions.isDefaultEventActions)(lastEvent.actions);
       if ((0, import_event.isFinalResponse)(lastEvent) && !(isEmptyMetadataEvent && stepHadToolCalls)) {
         break;
       }
@@ -1239,9 +1240,9 @@ const _LlmAgent = class _LlmAgent extends (_b = import_base_agent.BaseAgent, _a
   // --------------------------------------------------------------------------
   // #END LlmFlow Logic
   // --------------------------------------------------------------------------
-  // TODO - b/425992518: omitted Py LlmAgent features.
-  // - code_executor
-  // - configurable agents by yaml config
+  // TODO - b/425992518: LlmAgent features not implemented yet.
+  // - codeExecutor
+  // - configuring agents from a YAML file
 };
 __name(_LlmAgent, "LlmAgent");
 let LlmAgent = _LlmAgent;

package/dist/cjs/agents/loop_agent.js

@@ -45,7 +45,7 @@ var import_base_agent = require("./base_agent.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a, _b;
-const LOOP_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.loopAgent");
+const LOOP_AGENT_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.loopAgent");
 function isLoopAgent(obj) {
   return typeof obj === "object" && obj !== null && LOOP_AGENT_SIGNATURE_SYMBOL in obj && obj[LOOP_AGENT_SIGNATURE_SYMBOL] === true;
 }

package/dist/cjs/agents/parallel_agent.js

@@ -46,7 +46,7 @@ var import_invocation_context = require("./invocation_context.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a, _b;
-const PARALLEL_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.parallelAgent");
+const PARALLEL_AGENT_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.parallelAgent");
 function isParallelAgent(obj) {
   return typeof obj === "object" && obj !== null && PARALLEL_AGENT_SIGNATURE_SYMBOL in obj && obj[PARALLEL_AGENT_SIGNATURE_SYMBOL] === true;
 }

package/dist/cjs/agents/processors/agent_transfer_llm_request_processor.js

@@ -44,17 +44,34 @@ const _AgentTransferLlmRequestProcessor = class _AgentTransferLlmRequestProcesso
   constructor() {
     super(...arguments);
     this.toolName = "transfer_to_agent";
-    this.tool = new import_function_tool.FunctionTool({
+  }
+  /**
+   * Builds the `transfer_to_agent` tool for one invocation.
+   *
+   * Built per call rather than shared, because the parameter is an enum of the
+   * agents actually reachable from here. That mirrors adk-python's
+   * `TransferToAgentTool`, and it stops the model inventing a target: an
+   * unknown name now fails argument validation and comes back to the model as
+   * a tool error it can retry, instead of silently setting `transferToAgent`
+   * to an agent that does not exist.
+   *
+   * The parameter is `agent_name`, not `agentName`. It is wire format — it
+   * appears in the declaration sent to the model and in the events that get
+   * persisted — and adk-python spells it `agent_name`, so a transcript
+   * produced by one runtime has to be readable by the other.
+   */
+  buildTool(targetNames) {
+    return new import_function_tool.FunctionTool({
       name: this.toolName,
       description: "Transfer the question to another agent. This tool hands off control to another agent when it is more suitable to answer the user question according to the agent description.",
       parameters: import_zod.z.object({
-        agentName: import_zod.z.string().describe("the agent name to transfer to.")
+        agent_name: import_zod.z.enum(targetNames).describe("the agent name to transfer to.")
       }),
-      execute: /* @__PURE__ */ __name(function(args, toolContext) {
+      execute: /* @__PURE__ */ __name((args, toolContext) => {
         if (!toolContext) {
           throw new Error("toolContext is required.");
         }
-        toolContext.actions.transferToAgent = args.agentName;
+        toolContext.actions.transferToAgent = args.agent_name;
         return "Transfer queued";
       }, "execute")
     });
@@ -82,7 +99,11 @@ const _AgentTransferLlmRequestProcessor = class _AgentTransferLlmRequestProcesso
       )
     ]);
     const toolContext = new import_context.Context({ invocationContext });
-    await this.tool.processLlmRequest({ toolContext, llmRequest });
+    const targetNames = transferTargets.map((t) => t.name);
+    await this.buildTool(targetNames).processLlmRequest({
+      toolContext,
+      llmRequest
+    });
   }
   buildTargetAgentsInfo(targetAgent) {
     return `

package/dist/cjs/agents/processors/code_execution_request_processor.js

@@ -63,10 +63,10 @@ const _CodeExecutionRequestProcessor = class _CodeExecutionRequestProcessor exte
       return;
     }
     for (const content of llmRequest.contents) {
-      const delimeters = invocationContext.agent.codeExecutor.codeBlockDelimiters.length ? invocationContext.agent.codeExecutor.codeBlockDelimiters[0] : ["", ""];
+      const delimiters = invocationContext.agent.codeExecutor.codeBlockDelimiters.length ? invocationContext.agent.codeExecutor.codeBlockDelimiters[0] : ["", ""];
       (0, import_code_execution_utils.convertCodeExecutionParts)(
         content,
-        delimeters,
+        delimiters,
         invocationContext.agent.codeExecutor.executionResultDelimiters
       );
     }

package/dist/cjs/agents/processors/content_processor_utils.js

@@ -36,6 +36,7 @@ var import_lodash_es = require("lodash-es");
 var import_compacted_event = require("../../events/compacted_event.js");
 var import_event = require("../../events/event.js");
 var import_branch_trie = require("../../utils/branch_trie.js");
+var import_compaction_utils = require("../../context/compaction_utils.js");
 var import_functions = require("../functions.js");
 /**
  * @license
@@ -57,6 +58,9 @@ __name(removeClientFunctionCallId, "removeClientFunctionCallId");
 function getContents(events, agentName, currentBranch, currentIsolationScope) {
   const filteredEvents = [];
   for (const event of events) {
+    if (!(0, import_compaction_utils.isEventVisibleInIsolationScope)(event, currentIsolationScope)) {
+      continue;
+    }
     if ((0, import_compacted_event.isCompactedEvent)(event)) {
       filteredEvents.push(convertCompactedEvent(event));
       continue;
@@ -87,7 +91,7 @@ function shouldIncludeEventInContext(event, currentBranch, currentIsolationScope
   if (currentBranch && event.branch && !(0, import_branch_trie.isSegmentPrefix)(currentBranch, event.branch)) {
     return false;
   }
-  if (isOutsideIsolationScope(event, currentIsolationScope)) {
+  if (!(0, import_compaction_utils.isEventVisibleInIsolationScope)(event, currentIsolationScope)) {
     return false;
   }
   return !isAuthEvent(event) && !isToolConfirmationEvent(event) && !isRequestInputEvent(event);
@@ -152,10 +156,6 @@ function turnStart(events, anchor) {
   return start;
 }
 __name(turnStart, "turnStart");
-function isOutsideIsolationScope(event, currentIsolationScope) {
-  return event.isolationScope !== void 0 && event.isolationScope !== currentIsolationScope;
-}
-__name(isOutsideIsolationScope, "isOutsideIsolationScope");
 function isAuthEvent(event) {
   var _a, _b, _c;
   if (!((_a = event.content) == null ? void 0 : _a.parts)) {

package/dist/cjs/agents/processors/content_request_processor.js

@@ -51,7 +51,10 @@ const _ContentRequestProcessor = class _ContentRequestProcessor {
     if (!agent || !(0, import_llm_agent.isLlmAgent)(agent)) {
       return;
     }
-    const events = (0, import_compaction_utils.getActiveEvents)(invocationContext.session.events);
+    const events = (0, import_compaction_utils.getActiveEvents)(
+      invocationContext.session.events,
+      invocationContext.isolationScope
+    );
     if (agent.includeContents === "default") {
       llmRequest.contents = (0, import_content_processor_utils.getContents)(
         events,

package/dist/cjs/agents/processors/request_confirmation_llm_request_processor.js

@@ -73,7 +73,8 @@ const _RequestConfirmationLlmRequestProcessor = class _RequestConfirmationLlmReq
     }
     const approvals = collectApprovals(
       events,
-      (_a = runConfig == null ? void 0 : runConfig.plainTextToolConfirmation) != null ? _a : false
+      (_a = runConfig == null ? void 0 : runConfig.plainTextToolConfirmation) != null ? _a : false,
+      agent.name
     );
     if (approvals.size === 0) {
       return;
@@ -134,7 +135,7 @@ function eventsInScope(invocationContext) {
   );
 }
 __name(eventsInScope, "eventsInScope");
-function collectApprovals(events, allowPlainText) {
+function collectApprovals(events, allowPlainText, agentName) {
   const approvals = /* @__PURE__ */ new Map();
   const latestUserEvent = findLatestUserEvent(events);
   if (!latestUserEvent) {
@@ -153,7 +154,7 @@ function collectApprovals(events, allowPlainText) {
     );
   }
   if (approvals.size === 0 && allowPlainText) {
-    return mapPlainTextConfirmation(events);
+    return mapPlainTextConfirmation(events, agentName);
   }
   return approvals;
 }
@@ -185,6 +186,9 @@ function collectGateCandidates(events, approvals, agentName) {
             functionCallId: functionCall.id
           });
         }
+        import_logger.logger.debug(
+          `Skipping tool confirmation from event ${event.id}: authored by ${event.author}, not by ${agentName}.`
+        );
         continue;
       }
       const pinned = pinnedCall(functionCall);
@@ -197,7 +201,7 @@ function collectGateCandidates(events, approvals, agentName) {
           functionCallId: functionCall.id
         });
       }
-      if (hasRespondedAfter(events, pinned.id, index)) {
+      if (hasRespondedAfter(events, pinned.id, index, agentName)) {
         continue;
       }
       candidates.push({ pinned, confirmation });
@@ -257,16 +261,16 @@ function agentAuthoredCalls(events, agentName) {
 }
 __name(agentAuthoredCalls, "agentAuthoredCalls");
 function dynamicallyRequestedCallIds(events, agentName) {
+  var _a;
   const requested = /* @__PURE__ */ new Set();
   for (const event of events) {
     if (event.author !== agentName) {
       continue;
     }
-    const confirmations = event.actions.requestedToolConfirmations;
-    for (const functionResponse of (0, import_event.getFunctionResponses)(event)) {
-      if (functionResponse.id && functionResponse.id in confirmations) {
-        requested.add(functionResponse.id);
-      }
+    for (const functionCallId of Object.keys(
+      (_a = event.actions.requestedToolConfirmations) != null ? _a : {}
+    )) {
+      requested.add(functionCallId);
     }
   }
   return requested;
@@ -284,9 +288,9 @@ function pinnedCall(functionCall) {
   return pinned;
 }
 __name(pinnedCall, "pinnedCall");
-function hasRespondedAfter(events, pinnedCallId, gateIndex) {
+function hasRespondedAfter(events, pinnedCallId, gateIndex, agentName) {
   return events.slice(gateIndex + 1).some(
-    (event) => (0, import_event.getFunctionResponses)(event).some(
+    (event) => event.author === agentName && (0, import_event.getFunctionResponses)(event).some(
       (functionResponse) => functionResponse.id === pinnedCallId
     )
   );
@@ -323,7 +327,7 @@ const NEGATIVE = /* @__PURE__ */ new Set([
   "cancel",
   "cancelled"
 ]);
-function mapPlainTextConfirmation(events) {
+function mapPlainTextConfirmation(events, agentName) {
   var _a, _b;
   const none = /* @__PURE__ */ new Map();
   let turnIndex = -1;
@@ -361,6 +365,9 @@ function mapPlainTextConfirmation(events) {
     if (event.author === "user") {
       break;
     }
+    if (event.author !== agentName) {
+      continue;
+    }
     for (const fc of (0, import_event.getFunctionCalls)(event)) {
       if (fc.name === import_functions.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME && fc.id && !answered.has(fc.id)) {
         pendingId = fc.id;

package/dist/cjs/agents/processors/request_input_llm_request_processor.js

@@ -30,7 +30,6 @@ __export(request_input_llm_request_processor_exports, {
 });
 module.exports = __toCommonJS(request_input_llm_request_processor_exports);
 var import_event = require("../../events/event.js");
-var import_tool_confirmation = require("../../tools/tool_confirmation.js");
 var import_async_queue = require("../../utils/async_queue.js");
 var import_node_tool = require("../../workflow/nodes/node_tool.js");
 var import_hitl_utils = require("../../workflow/utils/hitl_utils.js");
@@ -90,12 +89,9 @@ const _RequestInputLlmRequestProcessor = class _RequestInputLlmRequestProcessor
     if (Object.keys(pending).length === 0) {
       return;
     }
-    const toolConfirmationDict = {};
+    const resumeInputsDict = {};
     for (const id of Object.keys(pending)) {
-      toolConfirmationDict[id] = new import_tool_confirmation.ToolConfirmation({
-        confirmed: true,
-        payload: resumeInputs
-      });
+      resumeInputsDict[id] = resumeInputs;
     }
     const eventQueue = new import_async_queue.AsyncQueue();
     invocationContext.eventQueue = eventQueue;
@@ -108,7 +104,7 @@ const _RequestInputLlmRequestProcessor = class _RequestInputLlmRequestProcessor
           beforeToolCallbacks: agent.canonicalBeforeToolCallbacks,
           afterToolCallbacks: agent.canonicalAfterToolCallbacks,
           filters: new Set(Object.keys(pending)),
-          toolConfirmationDict
+          resumeInputsDict
         });
       } finally {
         eventQueue.close();

package/dist/cjs/agents/readonly_context.js

@@ -78,6 +78,12 @@ const _ReadonlyContext = class _ReadonlyContext {
       {}
     );
   }
+  /**
+   * Request-level metadata passed from an incoming A2A request or caller.
+   */
+  get a2aMetadata() {
+    return this.invocationContext.a2aMetadata;
+  }
 };
 __name(_ReadonlyContext, "ReadonlyContext");
 let ReadonlyContext = _ReadonlyContext;

package/dist/cjs/agents/routed_agent.js

@@ -37,7 +37,7 @@ var import_failover_utils = require("../utils/failover_utils.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a, _b;
-const ROUTED_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.routedAgent");
+const ROUTED_AGENT_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.routedAgent");
 function isRoutedAgent(obj) {
   return typeof obj === "object" && obj !== null && ROUTED_AGENT_SIGNATURE_SYMBOL in obj && obj[ROUTED_AGENT_SIGNATURE_SYMBOL] === true;
 }