@google/adk 1.6.0 → 2.0.0

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

@@ -9,6 +9,7 @@ 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 });
@@ -39,7 +40,7 @@ var import_base_llm_processor = require("./base_llm_processor.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class InstructionsLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+const _InstructionsLlmRequestProcessor = class _InstructionsLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
   /**
    * Handles instructions and global instructions for LLM flow.
    */
@@ -83,7 +84,9 @@ class InstructionsLlmRequestProcessor extends import_base_llm_processor.BaseLlmR
       ]);
     }
   }
-}
+};
+__name(_InstructionsLlmRequestProcessor, "InstructionsLlmRequestProcessor");
+let InstructionsLlmRequestProcessor = _InstructionsLlmRequestProcessor;
 const INSTRUCTIONS_LLM_REQUEST_PROCESSOR = new InstructionsLlmRequestProcessor();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -9,6 +9,7 @@ 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 });
@@ -35,7 +36,7 @@ var import_llm_agent = require("../llm_agent.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class InteractionsRequestProcessor {
+const _InteractionsRequestProcessor = class _InteractionsRequestProcessor {
   // eslint-disable-next-line require-yield
   async *runAsync(invocationContext, llmRequest) {
     const agent = invocationContext.agent;
@@ -54,7 +55,9 @@ class InteractionsRequestProcessor {
       }
     }
   }
-}
+};
+__name(_InteractionsRequestProcessor, "InteractionsRequestProcessor");
+let InteractionsRequestProcessor = _InteractionsRequestProcessor;
 const INTERACTIONS_REQUEST_PROCESSOR = new InteractionsRequestProcessor();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -9,6 +9,7 @@ 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 });
@@ -28,8 +29,12 @@ __export(request_confirmation_llm_request_processor_exports, {
   RequestConfirmationLlmRequestProcessor: () => RequestConfirmationLlmRequestProcessor
 });
 module.exports = __toCommonJS(request_confirmation_llm_request_processor_exports);
+var import_lodash_es = require("lodash-es");
 var import_event = require("../../events/event.js");
 var import_tool_confirmation = require("../../tools/tool_confirmation.js");
+var import_branch_trie = require("../../utils/branch_trie.js");
+var import_logger = require("../../utils/logger.js");
+var import_context = require("../context.js");
 var import_functions = require("../functions.js");
 var import_llm_agent = require("../llm_agent.js");
 var import_readonly_context = require("../readonly_context.js");
@@ -39,7 +44,7 @@ var import_base_llm_processor = require("./base_llm_processor.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class RequestConfirmationLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+const _RequestConfirmationLlmRequestProcessor = class _RequestConfirmationLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
   /**
    * Resumes tool calls that were paused for user confirmation, re-invoking
    * them with the confirmed or denied decision before the next LLM turn.
@@ -50,121 +55,337 @@ class RequestConfirmationLlmRequestProcessor extends import_base_llm_processor.B
    *   are ready to resume.
    */
   async *runAsync(invocationContext) {
+    var _a;
     const agent = invocationContext.agent;
     if (!(0, import_llm_agent.isLlmAgent)(agent)) {
       return;
     }
-    const events = invocationContext.session.events;
-    if (!events || events.length === 0) {
+    const events = eventsInScope(invocationContext);
+    if (events.length === 0) {
       return;
     }
-    const requestConfirmationFunctionResponses = {};
-    let confirmationEventIndex = -1;
-    for (let i = events.length - 1; i >= 0; i--) {
-      const event = events[i];
-      if (event.author !== "user") {
+    const runConfig = invocationContext.runConfig;
+    if ((runConfig == null ? void 0 : runConfig.remoteDelivered) && !runConfig.allowRemoteToolConfirmation) {
+      import_logger.logger.warn(
+        "Ignoring tool confirmation(s) delivered over A2A: a remote peer cannot answer a human-in-the-loop gate. Set `allowRemoteToolConfirmation` on the run config if the peer relays a real operator decision."
+      );
+      return;
+    }
+    const approvals = collectApprovals(
+      events,
+      (_a = runConfig == null ? void 0 : runConfig.plainTextToolConfirmation) != null ? _a : false
+    );
+    if (approvals.size === 0) {
+      return;
+    }
+    const candidates = collectGateCandidates(events, approvals, agent.name);
+    if (candidates.length === 0) {
+      return;
+    }
+    const toolsList = await agent.canonicalTools(
+      new import_readonly_context.ReadonlyContext(invocationContext)
+    );
+    const toolsDict = Object.fromEntries(
+      toolsList.map((tool) => [tool.name, tool])
+    );
+    const resumable = await bindApprovedCalls({
+      candidates,
+      events,
+      toolsDict,
+      agentName: agent.name,
+      invocationContext
+    });
+    const functionResponseEvent = await (0, import_functions.handleFunctionCallList)({
+      invocationContext,
+      functionCalls: [...resumable.values()].map((entry) => entry.call),
+      toolsDict,
+      beforeToolCallbacks: agent.canonicalBeforeToolCallbacks,
+      afterToolCallbacks: agent.canonicalAfterToolCallbacks,
+      filters: new Set(resumable.keys()),
+      toolConfirmationDict: Object.fromEntries(
+        [...resumable].map(([id, entry]) => [id, entry.confirmation])
+      )
+    });
+    if (!functionResponseEvent) {
+      return;
+    }
+    const sessionEvents = invocationContext.session.events;
+    const existing = sessionEvents.findIndex(
+      (e) => e.id === functionResponseEvent.id
+    );
+    if (existing >= 0) {
+      sessionEvents[existing] = functionResponseEvent;
+    } else {
+      sessionEvents.push(functionResponseEvent);
+    }
+    yield functionResponseEvent;
+  }
+};
+__name(_RequestConfirmationLlmRequestProcessor, "RequestConfirmationLlmRequestProcessor");
+let RequestConfirmationLlmRequestProcessor = _RequestConfirmationLlmRequestProcessor;
+function eventsInScope(invocationContext) {
+  const events = invocationContext.session.events;
+  const currentBranch = invocationContext.branch;
+  if (!currentBranch) {
+    return events;
+  }
+  return events.filter(
+    (event) => !event.branch || (0, import_branch_trie.isSegmentPrefix)(currentBranch, event.branch)
+  );
+}
+__name(eventsInScope, "eventsInScope");
+function collectApprovals(events, allowPlainText) {
+  const approvals = /* @__PURE__ */ new Map();
+  const latestUserEvent = findLatestUserEvent(events);
+  if (!latestUserEvent) {
+    return approvals;
+  }
+  for (const functionResponse of (0, import_event.getFunctionResponses)(latestUserEvent)) {
+    if (functionResponse.name !== import_functions.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
+      continue;
+    }
+    if (!functionResponse.id || !functionResponse.response) {
+      continue;
+    }
+    approvals.set(
+      functionResponse.id,
+      parseToolConfirmation(functionResponse.response)
+    );
+  }
+  if (approvals.size === 0 && allowPlainText) {
+    return mapPlainTextConfirmation(events);
+  }
+  return approvals;
+}
+__name(collectApprovals, "collectApprovals");
+function parseToolConfirmation(response) {
+  const fields = Object.keys(response).length === 1 && "response" in response ? JSON.parse(response["response"]) : response;
+  return new import_tool_confirmation.ToolConfirmation({
+    hint: fields["hint"],
+    payload: fields["payload"],
+    confirmed: fields["confirmed"] === true
+  });
+}
+__name(parseToolConfirmation, "parseToolConfirmation");
+function collectGateCandidates(events, approvals, agentName) {
+  const candidates = [];
+  for (const [index, event] of events.entries()) {
+    for (const functionCall of (0, import_event.getFunctionCalls)(event)) {
+      const confirmation = functionCall.id ? approvals.get(functionCall.id) : void 0;
+      if (!confirmation) {
         continue;
       }
-      const responses = (0, import_event.getFunctionResponses)(event);
-      if (!responses) {
+      if (functionCall.name !== import_functions.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
         continue;
       }
-      let foundConfirmation = false;
-      for (const functionResponse of responses) {
-        if (functionResponse.name !== import_functions.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
-          continue;
-        }
-        foundConfirmation = true;
-        let toolConfirmation = null;
-        if (functionResponse.response && Object.keys(functionResponse.response).length === 1 && "response" in functionResponse.response) {
-          toolConfirmation = JSON.parse(
-            functionResponse.response["response"]
-          );
-        } else if (functionResponse.response) {
-          toolConfirmation = new import_tool_confirmation.ToolConfirmation({
-            hint: functionResponse.response["hint"],
-            payload: functionResponse.response["payload"],
-            confirmed: functionResponse.response["confirmed"]
+      if (event.author !== agentName) {
+        if (event.author === "user") {
+          throw new import_tool_confirmation.IntentMismatchError({
+            reason: "untrusted_request",
+            functionCallId: functionCall.id
           });
         }
-        if (functionResponse.id && toolConfirmation) {
-          requestConfirmationFunctionResponses[functionResponse.id] = toolConfirmation;
-        }
-      }
-      if (foundConfirmation) {
-        confirmationEventIndex = i;
-        break;
+        continue;
       }
-    }
-    if (Object.keys(requestConfirmationFunctionResponses).length === 0) {
-      return;
-    }
-    for (let i = confirmationEventIndex - 1; i >= 0; i--) {
-      const event = events[i];
-      const functionCalls = (0, import_event.getFunctionCalls)(event);
-      if (!functionCalls) {
+      const pinned = pinnedCall(functionCall);
+      if (!pinned) {
         continue;
       }
-      const toolsToResumeWithConfirmation = {};
-      const toolsToResumeWithArgs = {};
-      for (const functionCall of functionCalls) {
-        if (!functionCall.id || !(functionCall.id in requestConfirmationFunctionResponses)) {
-          continue;
-        }
-        const args = functionCall.args;
-        if (!args || !("originalFunctionCall" in args)) {
-          continue;
-        }
-        const originalFunctionCall = args["originalFunctionCall"];
-        if (originalFunctionCall.id) {
-          toolsToResumeWithConfirmation[originalFunctionCall.id] = requestConfirmationFunctionResponses[functionCall.id];
-          toolsToResumeWithArgs[originalFunctionCall.id] = originalFunctionCall;
-        }
+      if (!pinned.id || !pinned.name) {
+        throw new import_tool_confirmation.IntentMismatchError({
+          reason: "malformed_request",
+          functionCallId: functionCall.id
+        });
       }
-      if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
+      if (hasRespondedAfter(events, pinned.id, index)) {
         continue;
       }
-      for (let j = events.length - 1; j > confirmationEventIndex; j--) {
-        const eventToCheck = events[j];
-        const functionResponses = (0, import_event.getFunctionResponses)(eventToCheck);
-        if (!functionResponses) {
-          continue;
-        }
-        for (const fr of functionResponses) {
-          if (fr.id && fr.id in toolsToResumeWithConfirmation) {
-            delete toolsToResumeWithConfirmation[fr.id];
-            delete toolsToResumeWithArgs[fr.id];
-          }
-        }
-        if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
-          break;
-        }
+      candidates.push({ pinned, confirmation });
+    }
+  }
+  return candidates;
+}
+__name(collectGateCandidates, "collectGateCandidates");
+async function bindApprovedCalls(options) {
+  var _a, _b, _c;
+  const { candidates, events, toolsDict, agentName, invocationContext } = options;
+  const history = agentAuthoredCalls(events, agentName);
+  const dynamicallyRequested = dynamicallyRequestedCallIds(events, agentName);
+  const resumable = /* @__PURE__ */ new Map();
+  for (const { pinned, confirmation } of candidates) {
+    const pinnedId = pinned.id;
+    const refuse = /* @__PURE__ */ __name((reason) => new import_tool_confirmation.IntentMismatchError({ reason, functionCallId: pinnedId }), "refuse");
+    const original = history.get(pinnedId);
+    if (!original) {
+      throw refuse("unknown_original_call");
+    }
+    const tool = toolsDict[pinned.name];
+    if (!tool) {
+      throw refuse("unregistered_tool");
+    }
+    if (original.name !== pinned.name) {
+      throw refuse("tool_name_mismatch");
+    }
+    if (!(0, import_lodash_es.isEqual)((_a = original.args) != null ? _a : {}, (_b = pinned.args) != null ? _b : {})) {
+      throw refuse("arguments_mismatch");
+    }
+    const gates = await tool.checkRequireConfirmation(
+      (_c = original.args) != null ? _c : {},
+      new import_context.Context({ invocationContext, functionCallId: pinnedId })
+    );
+    if (!gates && !dynamicallyRequested.has(pinnedId)) {
+      throw refuse("confirmation_not_required");
+    }
+    resumable.set(pinnedId, { call: pinned, confirmation });
+  }
+  return resumable;
+}
+__name(bindApprovedCalls, "bindApprovedCalls");
+function agentAuthoredCalls(events, agentName) {
+  const calls = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.author !== agentName) {
+      continue;
+    }
+    for (const functionCall of (0, import_event.getFunctionCalls)(event)) {
+      if (functionCall.id && functionCall.name !== import_functions.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
+        calls.set(functionCall.id, functionCall);
       }
-      if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
-        continue;
+    }
+  }
+  return calls;
+}
+__name(agentAuthoredCalls, "agentAuthoredCalls");
+function dynamicallyRequestedCallIds(events, agentName) {
+  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);
       }
-      const toolsList = await agent.canonicalTools(
-        new import_readonly_context.ReadonlyContext(invocationContext)
-      );
-      const toolsDict = Object.fromEntries(
-        toolsList.map((tool) => [tool.name, tool])
-      );
-      const functionResponseEvent = await (0, import_functions.handleFunctionCallList)({
-        invocationContext,
-        functionCalls: Object.values(toolsToResumeWithArgs),
-        toolsDict,
-        beforeToolCallbacks: agent.canonicalBeforeToolCallbacks,
-        afterToolCallbacks: agent.canonicalAfterToolCallbacks,
-        filters: new Set(Object.keys(toolsToResumeWithConfirmation)),
-        toolConfirmationDict: toolsToResumeWithConfirmation
-      });
-      if (functionResponseEvent) {
-        yield functionResponseEvent;
+    }
+  }
+  return requested;
+}
+__name(dynamicallyRequestedCallIds, "dynamicallyRequestedCallIds");
+function pinnedCall(functionCall) {
+  const args = functionCall.args;
+  if (!args || !("originalFunctionCall" in args)) {
+    return void 0;
+  }
+  const pinned = args["originalFunctionCall"];
+  if (typeof pinned !== "object" || pinned === null || Array.isArray(pinned)) {
+    return void 0;
+  }
+  return pinned;
+}
+__name(pinnedCall, "pinnedCall");
+function hasRespondedAfter(events, pinnedCallId, gateIndex) {
+  return events.slice(gateIndex + 1).some(
+    (event) => (0, import_event.getFunctionResponses)(event).some(
+      (functionResponse) => functionResponse.id === pinnedCallId
+    )
+  );
+}
+__name(hasRespondedAfter, "hasRespondedAfter");
+function findLatestUserEvent(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    if (events[i].author === "user") {
+      return events[i];
+    }
+  }
+  return void 0;
+}
+__name(findLatestUserEvent, "findLatestUserEvent");
+const AFFIRMATIVE = /* @__PURE__ */ new Set([
+  "yes",
+  "y",
+  "true",
+  "approve",
+  "approved",
+  "ok",
+  "okay",
+  "confirm",
+  "confirmed"
+]);
+const NEGATIVE = /* @__PURE__ */ new Set([
+  "no",
+  "n",
+  "false",
+  "reject",
+  "rejected",
+  "deny",
+  "denied",
+  "cancel",
+  "cancelled"
+]);
+function mapPlainTextConfirmation(events) {
+  var _a, _b;
+  const none = /* @__PURE__ */ new Map();
+  let turnIndex = -1;
+  let text = "";
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.author !== "user") {
+      continue;
+    }
+    const parts = (_b = (_a = event.content) == null ? void 0 : _a.parts) != null ? _b : [];
+    const isPlainText = parts.length > 0 && parts.every((p) => typeof p.text === "string");
+    if (isPlainText) {
+      turnIndex = i;
+      text = parts.map((p) => p.text).join("");
+    }
+    break;
+  }
+  if (turnIndex < 0) {
+    return none;
+  }
+  const answered = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (event.author !== "user") {
+      continue;
+    }
+    for (const fr of (0, import_event.getFunctionResponses)(event)) {
+      if (fr.id) {
+        answered.add(fr.id);
       }
-      return;
     }
   }
+  let pendingId;
+  for (let i = turnIndex - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.author === "user") {
+      break;
+    }
+    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;
+        break;
+      }
+    }
+    if (pendingId) {
+      break;
+    }
+  }
+  if (!pendingId) {
+    return none;
+  }
+  const normalized = text.trim().toLowerCase();
+  let confirmed;
+  if (AFFIRMATIVE.has(normalized)) {
+    confirmed = true;
+  } else if (NEGATIVE.has(normalized)) {
+    confirmed = false;
+  } else {
+    return none;
+  }
+  return /* @__PURE__ */ new Map([[pendingId, new import_tool_confirmation.ToolConfirmation({ confirmed })]]);
 }
+__name(mapPlainTextConfirmation, "mapPlainTextConfirmation");
 const REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR = new RequestConfirmationLlmRequestProcessor();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {