@google/adk 1.6.0 → 2.0.0

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

@@ -1,6 +1,8 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
 var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __await = function(promise, isYieldStar) {
   this[0] = promise;
   this[1] = isYieldStar;
@@ -27,7 +29,7 @@ import { injectSessionState } from "../instructions.js";
 import { isLlmAgent } from "../llm_agent.js";
 import { ReadonlyContext } from "../readonly_context.js";
 import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
-class InstructionsLlmRequestProcessor extends BaseLlmRequestProcessor {
+const _InstructionsLlmRequestProcessor = class _InstructionsLlmRequestProcessor extends BaseLlmRequestProcessor {
   /**
    * Handles instructions and global instructions for LLM flow.
    */
@@ -73,7 +75,9 @@ class InstructionsLlmRequestProcessor extends BaseLlmRequestProcessor {
       }
     });
   }
-}
+};
+__name(_InstructionsLlmRequestProcessor, "InstructionsLlmRequestProcessor");
+let InstructionsLlmRequestProcessor = _InstructionsLlmRequestProcessor;
 const INSTRUCTIONS_LLM_REQUEST_PROCESSOR = new InstructionsLlmRequestProcessor();
 export {
   INSTRUCTIONS_LLM_REQUEST_PROCESSOR,

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

@@ -1,6 +1,8 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
 var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __await = function(promise, isYieldStar) {
   this[0] = promise;
   this[1] = isYieldStar;
@@ -23,7 +25,7 @@ var __asyncGenerator = (__this, __arguments, generator) => {
  */
 import { isGemini } from "../../models/google_llm.js";
 import { isLlmAgent } from "../llm_agent.js";
-class InteractionsRequestProcessor {
+const _InteractionsRequestProcessor = class _InteractionsRequestProcessor {
   // eslint-disable-next-line require-yield
   runAsync(invocationContext, llmRequest) {
     return __asyncGenerator(this, null, function* () {
@@ -44,7 +46,9 @@ class InteractionsRequestProcessor {
       }
     });
   }
-}
+};
+__name(_InteractionsRequestProcessor, "InteractionsRequestProcessor");
+let InteractionsRequestProcessor = _InteractionsRequestProcessor;
 const INTERACTIONS_REQUEST_PROCESSOR = new InteractionsRequestProcessor();
 export {
   INTERACTIONS_REQUEST_PROCESSOR,

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

@@ -1,6 +1,8 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
 var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __await = function(promise, isYieldStar) {
   this[0] = promise;
   this[1] = isYieldStar;
@@ -21,11 +23,18 @@ var __asyncGenerator = (__this, __arguments, generator) => {
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { isEqual } from "lodash-es";
 import {
   getFunctionCalls,
   getFunctionResponses
 } from "../../events/event.js";
-import { ToolConfirmation } from "../../tools/tool_confirmation.js";
+import {
+  IntentMismatchError,
+  ToolConfirmation
+} from "../../tools/tool_confirmation.js";
+import { isSegmentPrefix } from "../../utils/branch_trie.js";
+import { logger } from "../../utils/logger.js";
+import { Context } from "../context.js";
 import {
   REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
   handleFunctionCallList
@@ -33,7 +42,7 @@ import {
 import { isLlmAgent } from "../llm_agent.js";
 import { ReadonlyContext } from "../readonly_context.js";
 import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
-class RequestConfirmationLlmRequestProcessor extends BaseLlmRequestProcessor {
+const _RequestConfirmationLlmRequestProcessor = class _RequestConfirmationLlmRequestProcessor extends BaseLlmRequestProcessor {
   /**
    * Resumes tool calls that were paused for user confirmation, re-invoking
    * them with the confirmed or denied decision before the next LLM turn.
@@ -45,122 +54,338 @@ class RequestConfirmationLlmRequestProcessor extends BaseLlmRequestProcessor {
    */
   runAsync(invocationContext) {
     return __asyncGenerator(this, null, function* () {
+      var _a;
       const agent = invocationContext.agent;
       if (!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") {
-          continue;
-        }
-        const responses = getFunctionResponses(event);
-        if (!responses) {
-          continue;
-        }
-        let foundConfirmation = false;
-        for (const functionResponse of responses) {
-          if (functionResponse.name !== 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 ToolConfirmation({
-              hint: functionResponse.response["hint"],
-              payload: functionResponse.response["payload"],
-              confirmed: functionResponse.response["confirmed"]
-            });
-          }
-          if (functionResponse.id && toolConfirmation) {
-            requestConfirmationFunctionResponses[functionResponse.id] = toolConfirmation;
-          }
-        }
-        if (foundConfirmation) {
-          confirmationEventIndex = i;
-          break;
-        }
+      const runConfig = invocationContext.runConfig;
+      if ((runConfig == null ? void 0 : runConfig.remoteDelivered) && !runConfig.allowRemoteToolConfirmation) {
+        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;
       }
-      if (Object.keys(requestConfirmationFunctionResponses).length === 0) {
+      const approvals = collectApprovals(
+        events,
+        (_a = runConfig == null ? void 0 : runConfig.plainTextToolConfirmation) != null ? _a : false
+      );
+      if (approvals.size === 0) {
         return;
       }
-      for (let i = confirmationEventIndex - 1; i >= 0; i--) {
-        const event = events[i];
-        const functionCalls = getFunctionCalls(event);
-        if (!functionCalls) {
-          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 (Object.keys(toolsToResumeWithConfirmation).length === 0) {
-          continue;
-        }
-        for (let j = events.length - 1; j > confirmationEventIndex; j--) {
-          const eventToCheck = events[j];
-          const functionResponses = 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;
-          }
-        }
-        if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
-          continue;
-        }
-        const toolsList = yield new __await(agent.canonicalTools(
-          new ReadonlyContext(invocationContext)
-        ));
-        const toolsDict = Object.fromEntries(
-          toolsList.map((tool) => [tool.name, tool])
-        );
-        const functionResponseEvent = yield new __await(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;
-        }
+      const candidates = collectGateCandidates(events, approvals, agent.name);
+      if (candidates.length === 0) {
         return;
       }
+      const toolsList = yield new __await(agent.canonicalTools(
+        new ReadonlyContext(invocationContext)
+      ));
+      const toolsDict = Object.fromEntries(
+        toolsList.map((tool) => [tool.name, tool])
+      );
+      const resumable = yield new __await(bindApprovedCalls({
+        candidates,
+        events,
+        toolsDict,
+        agentName: agent.name,
+        invocationContext
+      }));
+      const functionResponseEvent = yield new __await(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 || 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 getFunctionResponses(latestUserEvent)) {
+    if (functionResponse.name !== 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 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 getFunctionCalls(event)) {
+      const confirmation = functionCall.id ? approvals.get(functionCall.id) : void 0;
+      if (!confirmation) {
+        continue;
+      }
+      if (functionCall.name !== REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
+        continue;
+      }
+      if (event.author !== agentName) {
+        if (event.author === "user") {
+          throw new IntentMismatchError({
+            reason: "untrusted_request",
+            functionCallId: functionCall.id
+          });
+        }
+        continue;
+      }
+      const pinned = pinnedCall(functionCall);
+      if (!pinned) {
+        continue;
+      }
+      if (!pinned.id || !pinned.name) {
+        throw new IntentMismatchError({
+          reason: "malformed_request",
+          functionCallId: functionCall.id
+        });
+      }
+      if (hasRespondedAfter(events, pinned.id, index)) {
+        continue;
+      }
+      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 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 (!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 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 getFunctionCalls(event)) {
+      if (functionCall.id && functionCall.name !== REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
+        calls.set(functionCall.id, functionCall);
+      }
+    }
+  }
+  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 getFunctionResponses(event)) {
+      if (functionResponse.id && functionResponse.id in confirmations) {
+        requested.add(functionResponse.id);
+      }
+    }
+  }
+  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) => 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 getFunctionResponses(event)) {
+      if (fr.id) {
+        answered.add(fr.id);
+      }
+    }
+  }
+  let pendingId;
+  for (let i = turnIndex - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.author === "user") {
+      break;
+    }
+    for (const fc of getFunctionCalls(event)) {
+      if (fc.name === 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 ToolConfirmation({ confirmed })]]);
 }
+__name(mapPlainTextConfirmation, "mapPlainTextConfirmation");
 const REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR = new RequestConfirmationLlmRequestProcessor();
 export {
   REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,