@google/adk 1.5.0 → 2.0.0

package/dist/esm/agents/processors/identity_llm_request_processor.js

@@ -1,30 +1,39 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 import { appendInstructions } from "../../models/llm_request.js";
+import { requireAgent } from "../invocation_context.js";
+import { isLlmAgent } from "../llm_agent.js";
 import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
-class IdentityLlmRequestProcessor extends BaseLlmRequestProcessor {
+const _IdentityLlmRequestProcessor = class _IdentityLlmRequestProcessor extends BaseLlmRequestProcessor {
   /**
    * Appends agent name and description as identity instructions to the system
-   * prompt of the request.
+   * prompt of the request, unless the agent has no reachable transfer target.
    *
    * @param invocationContext - The current invocation context.
    * @param llmRequest - The request object to append instructions to.
    */
   // eslint-disable-next-line require-yield
   async *runAsync(invocationContext, llmRequest) {
-    const agent = invocationContext.agent;
+    const agent = requireAgent(invocationContext);
+    if (isLlmAgent(agent) && agent.disallowTransferToParent && agent.disallowTransferToPeers && agent.subAgents.length === 0) {
+      return;
+    }
     const si = [`You are an agent. Your internal name is "${agent.name}".`];
     if (agent.description) {
       si.push(`The description about you is "${agent.description}"`);
     }
     appendInstructions(llmRequest, si);
   }
-}
+};
+__name(_IdentityLlmRequestProcessor, "IdentityLlmRequestProcessor");
+let IdentityLlmRequestProcessor = _IdentityLlmRequestProcessor;
 const IDENTITY_LLM_REQUEST_PROCESSOR = new IdentityLlmRequestProcessor();
 export {
   IDENTITY_LLM_REQUEST_PROCESSOR,

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

@@ -1,21 +1,25 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 import { appendInstructions } from "../../models/llm_request.js";
+import { canUseOutputSchemaWithTools } from "../../utils/output_schema_utils.js";
 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.
    */
   // eslint-disable-next-line require-yield
   async *runAsync(invocationContext, llmRequest) {
+    var _a;
     const agent = invocationContext.agent;
     if (!isLlmAgent(agent)) {
       return;
@@ -47,13 +51,15 @@ class InstructionsLlmRequestProcessor extends BaseLlmRequestProcessor {
       }
       appendInstructions(llmRequest, [instructionWithState]);
     }
-    if (agent.outputSchema && agent.tools && agent.tools.length > 0) {
+    if (agent.outputSchema && ((_a = agent.tools) == null ? void 0 : _a.length) && !canUseOutputSchemaWithTools(agent.canonicalModel.model)) {
       appendInstructions(llmRequest, [
         'To output the final result, you must call the "set_model_response" function with the appropriate values. Do not output anything else.'
       ]);
     }
   }
-}
+};
+__name(_InstructionsLlmRequestProcessor, "InstructionsLlmRequestProcessor");
+let InstructionsLlmRequestProcessor = _InstructionsLlmRequestProcessor;
 const INSTRUCTIONS_LLM_REQUEST_PROCESSOR = new InstructionsLlmRequestProcessor();
 export {
   INSTRUCTIONS_LLM_REQUEST_PROCESSOR,

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

@@ -1,5 +1,7 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -7,7 +9,7 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 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
   async *runAsync(invocationContext, llmRequest) {
     const agent = invocationContext.agent;
@@ -26,7 +28,9 @@ class InteractionsRequestProcessor {
       }
     }
   }
-}
+};
+__name(_InteractionsRequestProcessor, "InteractionsRequestProcessor");
+let InteractionsRequestProcessor = _InteractionsRequestProcessor;
 const INTERACTIONS_REQUEST_PROCESSOR = new InteractionsRequestProcessor();
 export {
   INTERACTIONS_REQUEST_PROCESSOR,

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

@@ -1,15 +1,24 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * 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
@@ -17,7 +26,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.
@@ -28,121 +37,337 @@ class RequestConfirmationLlmRequestProcessor extends BaseLlmRequestProcessor {
    *   are ready to resume.
    */
   async *runAsync(invocationContext) {
+    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 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;
+    }
+    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 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 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 requestConfirmationFunctionResponses = {};
-    let confirmationEventIndex = -1;
-    for (let i = events.length - 1; i >= 0; i--) {
-      const event = events[i];
-      if (event.author !== "user") {
+    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;
       }
-      const responses = getFunctionResponses(event);
-      if (!responses) {
+      if (functionCall.name !== REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
         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 (event.author !== agentName) {
+        if (event.author === "user") {
+          throw new 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 = 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 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 = 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 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);
       }
-      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 getFunctionResponses(event)) {
+      if (functionResponse.id && functionResponse.id in confirmations) {
+        requested.add(functionResponse.id);
       }
-      const toolsList = await agent.canonicalTools(
-        new ReadonlyContext(invocationContext)
-      );
-      const toolsDict = Object.fromEntries(
-        toolsList.map((tool) => [tool.name, tool])
-      );
-      const functionResponseEvent = 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;
+    }
+  }
+  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);
       }
-      return;
     }
   }
+  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,