@google/adk 1.2.0 → 1.3.0

package/dist/cjs/agents/base_agent.js

@@ -124,9 +124,27 @@ class BaseAgent {
         ctx,
         this,
         async function* () {
+          var _a2, _b;
+          const context2 = this.createInvocationContext(parentContext);
+          const beforeAgentCallbackEvent = await this.handleBeforeAgentCallback(context2);
+          if (beforeAgentCallbackEvent) {
+            yield beforeAgentCallbackEvent;
+          }
+          if (context2.endInvocation || ((_a2 = parentContext.abortSignal) == null ? void 0 : _a2.aborted)) {
+            return;
+          }
+          for await (const event of this.runLiveImpl(context2)) {
+            yield event;
+          }
+          if (context2.endInvocation || ((_b = parentContext.abortSignal) == null ? void 0 : _b.aborted)) {
+            return;
+          }
+          const afterAgentCallbackEvent = await this.handleAfterAgentCallback(context2);
+          if (afterAgentCallbackEvent) {
+            yield afterAgentCallbackEvent;
+          }
         }
       );
-      throw new Error("Live mode is not implemented yet.");
     } finally {
       span.end();
     }

package/dist/cjs/agents/instructions.js

@@ -33,50 +33,98 @@ var import_state = require("../sessions/state.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-async function injectSessionState(template, readonlyContext) {
+const ARTIFACT_PREFIX = "artifact.";
+async function resolveKey(key, isOptional, rawMatch, readonlyContext) {
   const invocationContext = readonlyContext.invocationContext;
-  async function replaceMatchedKeyWithItsValue(match) {
-    let key = match[0].replace(/^\{+/, "").replace(/\}+$/, "").trim();
+  if (key.startsWith(ARTIFACT_PREFIX)) {
+    const fileName = key.substring(ARTIFACT_PREFIX.length);
+    if (invocationContext.artifactService === void 0) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    const artifact = await invocationContext.artifactService.loadArtifact({
+      appName: invocationContext.session.appName,
+      userId: invocationContext.session.userId,
+      sessionId: invocationContext.session.id,
+      filename: fileName
+    });
+    if (!artifact) {
+      if (isOptional) {
+        return "";
+      }
+      throw new Error(`Artifact ${fileName} not found.`);
+    }
+    return String(artifact);
+  }
+  if (!isValidStateName(key)) {
+    return rawMatch;
+  }
+  if (key in invocationContext.session.state) {
+    return String(invocationContext.session.state[key]);
+  }
+  if (isOptional) {
+    return "";
+  }
+  throw new Error(`Context variable not found: \`${key}\`.`);
+}
+async function injectSessionState(template, readonlyContext) {
+  const pattern = /\{+[^{}]*}+/g;
+  const matches = Array.from(template.matchAll(pattern));
+  if (matches.length === 0) {
+    return template;
+  }
+  const parsedMatches = matches.map((match) => {
+    const raw = match[0];
+    let key = raw.replace(/^\{+/, "").replace(/\}+$/, "").trim();
     const isOptional = key.endsWith("?");
     if (isOptional) {
       key = key.slice(0, -1);
     }
-    if (key.startsWith("artifact.")) {
-      const fileName = key.substring("artifact.".length);
-      if (invocationContext.artifactService === void 0) {
-        throw new Error("Artifact service is not initialized.");
+    const isValid = key.startsWith(ARTIFACT_PREFIX) || isValidStateName(key);
+    return {
+      raw,
+      key,
+      isOptional,
+      isValid,
+      index: match.index
+    };
+  });
+  const uniqueKeys = /* @__PURE__ */ new Map();
+  for (const pm of parsedMatches) {
+    if (!pm.isValid) {
+      continue;
+    }
+    const existing = uniqueKeys.get(pm.key);
+    if (existing) {
+      if (existing.isOptional && !pm.isOptional) {
+        existing.isOptional = false;
       }
-      const artifact = await invocationContext.artifactService.loadArtifact({
-        appName: invocationContext.session.appName,
-        userId: invocationContext.session.userId,
-        sessionId: invocationContext.session.id,
-        filename: fileName
+    } else {
+      uniqueKeys.set(pm.key, {
+        key: pm.key,
+        isOptional: pm.isOptional,
+        raw: pm.raw
       });
-      if (!artifact) {
-        throw new Error(`Artifact ${fileName} not found.`);
-      }
-      return String(artifact);
-    }
-    if (!isValidStateName(key)) {
-      return match[0];
-    }
-    if (key in invocationContext.session.state) {
-      return String(invocationContext.session.state[key]);
     }
-    if (isOptional) {
-      return "";
-    }
-    throw new Error(`Context variable not found: \`${key}\`.`);
   }
-  const pattern = /\{+[^{}]*}+/g;
+  const resolutions = /* @__PURE__ */ new Map();
+  for (const info of uniqueKeys.values()) {
+    resolutions.set(
+      info.key,
+      resolveKey(info.key, info.isOptional, info.raw, readonlyContext)
+    );
+  }
+  await Promise.all(resolutions.values());
   const result = [];
   let lastEnd = 0;
-  const matches = template.matchAll(pattern);
-  for (const match of matches) {
-    result.push(template.slice(lastEnd, match.index));
-    const replacement = await replaceMatchedKeyWithItsValue(match);
-    result.push(replacement);
-    lastEnd = match.index + match[0].length;
+  for (const pm of parsedMatches) {
+    result.push(template.slice(lastEnd, pm.index));
+    if (pm.isValid) {
+      const replacement = await resolutions.get(pm.key);
+      result.push(replacement);
+    } else {
+      result.push(pm.raw);
+    }
+    lastEnd = pm.index + pm.raw.length;
   }
   result.push(template.slice(lastEnd));
   return result.join("");

package/dist/cjs/agents/invocation_context.js

@@ -74,7 +74,6 @@ class InvocationContext {
     this.endInvocation = params.endInvocation || false;
     this.transcriptionCache = params.transcriptionCache;
     this.runConfig = params.runConfig;
-    this.liveRequestQueue = params.liveRequestQueue;
     this.activeStreamingTools = params.activeStreamingTools;
     this.pluginManager = params.pluginManager;
     this.abortSignal = params.abortSignal;

package/dist/cjs/agents/llm_agent.js

@@ -29,6 +29,7 @@ __export(llm_agent_exports, {
 });
 module.exports = __toCommonJS(llm_agent_exports);
 var import_api = require("@opentelemetry/api");
+var import_function_tool = require("../tools/function_tool.js");
 var import_event = require("../events/event.js");
 var import_base_llm = require("../models/base_llm.js");
 var import_registry = require("../models/registry.js");
@@ -39,6 +40,7 @@ var import_tracing = require("../telemetry/tracing.js");
 var import_simple_zod_to_json = require("../utils/simple_zod_to_json.js");
 var import_base_agent = require("./base_agent.js");
 var import_functions = require("./functions.js");
+var import_auth_preprocessor = require("../auth/auth_preprocessor.js");
 var import_agent_transfer_llm_request_processor = require("./processors/agent_transfer_llm_request_processor.js");
 var import_basic_llm_request_processor = require("./processors/basic_llm_request_processor.js");
 var import_code_execution_request_processor = require("./processors/code_execution_request_processor.js");
@@ -91,6 +93,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     this.codeExecutor = config.codeExecutor;
     this.requestProcessors = (_g = config.requestProcessors) != null ? _g : [
       import_basic_llm_request_processor.BASIC_LLM_REQUEST_PROCESSOR,
+      import_auth_preprocessor.AUTH_PREPROCESSOR,
       import_identity_llm_request_processor.IDENTITY_LLM_REQUEST_PROCESSOR,
       import_instructions_llm_request_processor.INSTRUCTIONS_LLM_REQUEST_PROCESSOR,
       import_request_confirmation_llm_request_processor.REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
@@ -316,18 +319,26 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     event.actions.stateDelta[this.outputKey] = result;
   }
   async *runAsyncImpl(context2) {
-    var _a2;
+    var _a2, _b2;
     while (true) {
       let lastEvent = void 0;
+      let stepHadToolCalls = false;
       for await (const event of this.runOneStepAsync(context2)) {
         if ((_a2 = context2.abortSignal) == null ? void 0 : _a2.aborted) {
           return;
         }
         lastEvent = event;
+        if ((0, import_event.getFunctionCalls)(event).length > 0 || (0, import_event.getFunctionResponses)(event).length > 0) {
+          stepHadToolCalls = true;
+        }
         this.maybeSaveOutputToState(event);
         yield event;
       }
-      if (!lastEvent || (0, import_event.isFinalResponse)(lastEvent)) {
+      if (!lastEvent) {
+        break;
+      }
+      const isEmptyMetadataEvent = lastEvent.author === this.name && !lastEvent.partial && (!((_b2 = lastEvent.content) == null ? void 0 : _b2.parts) || lastEvent.content.parts.length === 0);
+      if ((0, import_event.isFinalResponse)(lastEvent) && !(isEmptyMetadataEvent && stepHadToolCalls)) {
         break;
       }
       if (lastEvent.partial) {
@@ -352,6 +363,20 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
   // --------------------------------------------------------------------------
   // #START LlmFlow Logic
   // --------------------------------------------------------------------------
+  /**
+   * Runs the bidirectional (live) flow for this agent.
+   *
+   * Establishes a live connection to the model, drains the invocation's
+   * `liveRequestQueue` into the connection on a parallel task, and yields
+   * events derived from server messages until the queue closes, the model
+   * finishes, or an agent transfer occurs.
+   *
+   * If the live connection drops (network failure, server `goAway`) and a
+   * session resumption handle has been observed, the flow transparently
+   * reconnects using that handle up to {@link MAX_LIVE_RECONNECT_ATTEMPTS}
+   * times. Subsequent reconnects skip `sendHistory` because the server
+   * already holds the conversation state associated with the handle.
+   */
   // eslint-disable-next-line require-yield
   async *runLiveFlow(_invocationContext) {
     await Promise.resolve();
@@ -375,13 +400,28 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
         yield event;
       }
     }
-    for (const toolUnion of this.tools) {
+    const allTools = [...this.tools];
+    if (this.outputSchema && allTools.length > 0) {
+      const setModelResponseTool = new import_function_tool.FunctionTool({
+        name: "set_model_response",
+        description: "Call this tool to submit your final response conforming to the output schema. Use this tool only when you have collected all the information and are ready to return the final answer.",
+        parameters: this.outputSchema,
+        execute: async (args, toolContext) => {
+          if (toolContext) {
+            toolContext.actions.skipSummarization = true;
+          }
+          return JSON.stringify(args);
+        }
+      });
+      allTools.push(setModelResponseTool);
+    }
+    for (const toolUnion of allTools) {
       const toolContext = new import_context.Context({ invocationContext });
       const tools = (await convertToolUnionToTools(
         toolUnion,
         new import_readonly_context.ReadonlyContext(invocationContext)
       )).filter((tool) => {
-        return !llmRequest.allowedTools || llmRequest.allowedTools.includes(tool.name);
+        return !llmRequest.allowedTools || llmRequest.allowedTools.includes(tool.name) || tool.name === "set_model_response";
       });
       for (const tool of tools) {
         await tool.processLlmRequest({ toolContext, llmRequest });
@@ -461,7 +501,14 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     });
     if (mergedEvent.content) {
       const functionCalls = (0, import_event.getFunctionCalls)(mergedEvent);
-      if (functionCalls == null ? void 0 : functionCalls.length) {
+      const setModelResponseCall = functionCalls.find(
+        (call) => call.name === "set_model_response"
+      );
+      if (setModelResponseCall) {
+        const args = setModelResponseCall.args;
+        mergedEvent.content.parts = [{ text: JSON.stringify(args) }];
+        mergedEvent.actions.skipSummarization = true;
+      } else if (functionCalls && functionCalls.length) {
         (0, import_functions.populateClientFunctionCallId)(mergedEvent);
         mergedEvent.longRunningToolIds = Array.from(
           (0, import_functions.getLongRunningFunctionCalls)(functionCalls, llmRequest.toolsDict)

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

@@ -58,6 +58,13 @@ class AgentTransferLlmRequestProcessor extends import_base_llm_processor.BaseLlm
       }
     });
   }
+  /**
+   * Appends transfer instructions and registers the `transfer_to_agent` tool
+   * when the agent has reachable transfer targets.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param llmRequest - The request to augment with transfer instructions and the transfer tool.
+   */
   // eslint-disable-next-line require-yield
   async *runAsync(invocationContext, llmRequest) {
     if (!(0, import_llm_agent.isLlmAgent)(invocationContext.agent)) {

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

@@ -37,6 +37,13 @@ var import_base_llm_processor = require("./base_llm_processor.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class BasicLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+  /**
+   * Populates model name, generation config, output schema, and live connect
+   * settings on the request from the agent and run config.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param llmRequest - The request object to populate in place.
+   */
   // eslint-disable-next-line require-yield
   async *runAsync(invocationContext, llmRequest) {
     var _a;
@@ -46,7 +53,7 @@ class BasicLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestP
     }
     llmRequest.model = agent.canonicalModel.model;
     llmRequest.config = { ...(_a = agent.generateContentConfig) != null ? _a : {} };
-    if (agent.outputSchema) {
+    if (agent.outputSchema && (!agent.tools || agent.tools.length === 0)) {
       (0, import_llm_request.setOutputSchema)(llmRequest, agent.outputSchema);
     }
     if (invocationContext.runConfig) {

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

@@ -25,7 +25,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var content_processor_utils_exports = {};
 __export(content_processor_utils_exports, {
   getContents: () => getContents,
-  getCurrentTurnContents: () => getCurrentTurnContents
+  getCurrentTurnContents: () => getCurrentTurnContents,
+  mergeFunctionResponseEvents: () => mergeFunctionResponseEvents
 });
 module.exports = __toCommonJS(content_processor_utils_exports);
 var import_genai = require("@google/genai");
@@ -127,17 +128,19 @@ function convertForeignEvent(event) {
         text: `[${event.author}] said: ${part.text}`
       });
     } else if (part.functionCall) {
-      const argsText = safeStringify(part.functionCall.args);
       (_d = content.parts) == null ? void 0 : _d.push({
-        text: `[${event.author}] called tool \`${part.functionCall.name}\` with parameters: ${argsText}`
+        text: `[${event.author}] called tool \`${part.functionCall.name}\` with parameters: ${safeStringify(
+          part.functionCall.args
+        )}`
       });
     } else if (part.functionResponse) {
-      const responseText = safeStringify(part.functionResponse.response);
       (_e = content.parts) == null ? void 0 : _e.push({
-        text: `[${event.author}] tool \`${part.functionResponse.name}\` returned result: ${responseText}`
+        text: `[${event.author}] tool \`${part.functionResponse.name}\` returned result: ${safeStringify(
+          part.functionResponse.response
+        )}`
       });
     } else {
-      (_f = content.parts) == null ? void 0 : _f.push(part);
+      (_f = content.parts) == null ? void 0 : _f.push((0, import_lodash_es.cloneDeep)(part));
     }
   }
   return (0, import_event.createEvent)({
@@ -153,9 +156,12 @@ function mergeFunctionResponseEvents(events) {
   if (events.length === 0) {
     throw new Error("Cannot merge an empty list of events.");
   }
-  const mergedEvent = (0, import_event.createEvent)(events[0]);
-  const partsInMergedEvent = ((_a = mergedEvent.content) == null ? void 0 : _a.parts) || [];
-  if (partsInMergedEvent.length === 0) {
+  const mergedEvent = (0, import_event.createEvent)({
+    ...events[0],
+    content: events[0].content ? (0, import_lodash_es.cloneDeep)(events[0].content) : void 0
+  });
+  const partsInMergedEvent = (_a = mergedEvent.content) == null ? void 0 : _a.parts;
+  if (!partsInMergedEvent || partsInMergedEvent.length === 0) {
     throw new Error("There should be at least one function_response part.");
   }
   const partIndicesInMergedEvent = {};
@@ -170,16 +176,17 @@ function mergeFunctionResponseEvents(events) {
       throw new Error("There should be at least one function_response part.");
     }
     for (const part of event.content.parts) {
-      if (part.functionResponse && part.functionResponse.id) {
-        const functionCallId = part.functionResponse.id;
+      const clonedPart = (0, import_lodash_es.cloneDeep)(part);
+      if (clonedPart.functionResponse && clonedPart.functionResponse.id) {
+        const functionCallId = clonedPart.functionResponse.id;
         if (functionCallId in partIndicesInMergedEvent) {
-          partsInMergedEvent[partIndicesInMergedEvent[functionCallId]] = part;
+          partsInMergedEvent[partIndicesInMergedEvent[functionCallId]] = clonedPart;
         } else {
-          partsInMergedEvent.push(part);
+          partsInMergedEvent.push(clonedPart);
           partIndicesInMergedEvent[functionCallId] = partsInMergedEvent.length - 1;
         }
       } else {
-        partsInMergedEvent.push(part);
+        partsInMergedEvent.push(clonedPart);
       }
     }
   }
@@ -194,7 +201,7 @@ function rearrangeEventsForLatestFunctionResponse(events) {
   if (!(functionResponses == null ? void 0 : functionResponses.length)) {
     return events;
   }
-  let functionResponsesIds = new Set(
+  const functionResponsesIds = new Set(
     functionResponses.filter((response) => !!response.id).map((response) => response.id)
   );
   const secondLatestEvent = events.at(-2);
@@ -208,16 +215,16 @@ function rearrangeEventsForLatestFunctionResponse(events) {
       }
     }
   }
-  let functionCallEventIdx = -1;
+  let match;
   for (let idx = events.length - 2; idx >= 0; idx--) {
     const event = events[idx];
     const functionCalls = (0, import_event.getFunctionCalls)(event);
     if (!(functionCalls == null ? void 0 : functionCalls.length)) {
       continue;
     }
+    let matchedInEvent = false;
     for (const functionCall of functionCalls) {
       if (functionCall.id && functionResponsesIds.has(functionCall.id)) {
-        functionCallEventIdx = idx;
         const functionCallIds = new Set(
           functionCalls.map((fc) => fc.id).filter((id) => !!id)
         );
@@ -231,12 +238,16 @@ function rearrangeEventsForLatestFunctionResponse(events) {
             )}, function response ids provided: ${Array.from(functionResponsesIds).join(", ")}`
           );
         }
-        functionResponsesIds = functionCallIds;
+        match = { eventIdx: idx, responseIds: functionCallIds };
+        matchedInEvent = true;
         break;
       }
     }
+    if (matchedInEvent) {
+      break;
+    }
   }
-  if (functionCallEventIdx === -1) {
+  if (!match) {
     throw new Error(
       `No function call event found for function responses ids: ${Array.from(
         functionResponsesIds
@@ -244,17 +255,18 @@ function rearrangeEventsForLatestFunctionResponse(events) {
     );
   }
   const functionResponseEvents = [];
-  for (let idx = functionCallEventIdx + 1; idx < events.length - 1; idx++) {
+  const activeResponses = match.responseIds;
+  for (let idx = match.eventIdx + 1; idx < events.length - 1; idx++) {
     const event = events[idx];
     const responses = (0, import_event.getFunctionResponses)(event);
     if (responses && responses.some(
-      (response) => response.id && functionResponsesIds.has(response.id)
+      (response) => response.id && activeResponses.has(response.id)
     )) {
       functionResponseEvents.push(event);
     }
   }
   functionResponseEvents.push(events[events.length - 1]);
-  const resultEvents = events.slice(0, functionCallEventIdx + 1);
+  const resultEvents = events.slice(0, match.eventIdx + 1);
   resultEvents.push(mergeFunctionResponseEvents(functionResponseEvents));
   return resultEvents;
 }
@@ -293,7 +305,7 @@ function rearrangeEventsForAsyncFunctionResponsesInHistory(events) {
         continue;
       }
       if (functionResponseEventsIndices.size === 1) {
-        const [responseIndex] = [...functionResponseEventsIndices];
+        const [responseIndex] = Array.from(functionResponseEventsIndices);
         resultEvents.push(events[responseIndex]);
       } else {
         const indicesArray = Array.from(functionResponseEventsIndices).sort(
@@ -334,5 +346,6 @@ ${event.compactedContent}`
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getContents,
-  getCurrentTurnContents
+  getCurrentTurnContents,
+  mergeFunctionResponseEvents
 });

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

@@ -37,6 +37,13 @@ var import_content_processor_utils = require("./content_processor_utils.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class ContentRequestProcessor {
+  /**
+   * Fills {@link LlmRequest.contents} based on the session event history and
+   * agent configuration.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param llmRequest - The request whose contents field will be populated.
+   */
   // eslint-disable-next-line require-yield
   async *runAsync(invocationContext, llmRequest) {
     const agent = invocationContext.agent;

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

@@ -34,9 +34,21 @@ var import_base_plugin = require("../../plugins/base_plugin.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class ContextCompactorRequestProcessor {
+  /**
+   * @param compactors - Ordered list of compactors to evaluate; the first one
+   *   that reports it should compact will perform the compaction.
+   */
   constructor(compactors) {
     this.compactors = compactors;
   }
+  /**
+   * Evaluates compactors in priority order. The first compactor that indicates
+   * it should compact will compact the session history, fire plugin hooks, and
+   * yield any newly generated events. Iteration stops after one compaction.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param _llmRequest - Unused; present to satisfy the {@link BaseLlmRequestProcessor} interface.
+   */
   async *runAsync(invocationContext, _llmRequest) {
     for (const compactor of this.compactors) {
       const shouldCompact = await Promise.resolve(

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

@@ -36,6 +36,13 @@ var import_base_llm_processor = require("./base_llm_processor.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class IdentityLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+  /**
+   * Appends agent name and description as identity instructions to the system
+   * prompt of the request.
+   *
+   * @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;

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

@@ -75,6 +75,11 @@ class InstructionsLlmRequestProcessor extends import_base_llm_processor.BaseLlmR
       }
       (0, import_llm_request.appendInstructions)(llmRequest, [instructionWithState]);
     }
+    if (agent.outputSchema && agent.tools && agent.tools.length > 0) {
+      (0, import_llm_request.appendInstructions)(llmRequest, [
+        'To output the final result, you must call the "set_model_response" function with the appropriate values. Do not output anything else.'
+      ]);
+    }
   }
 }
 const INSTRUCTIONS_LLM_REQUEST_PROCESSOR = new InstructionsLlmRequestProcessor();

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

@@ -40,7 +40,15 @@ var import_base_llm_processor = require("./base_llm_processor.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class RequestConfirmationLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
-  /** Handles tool confirmation information to build the LLM request. */
+  /**
+   * Resumes tool calls that were paused for user confirmation, re-invoking
+   * them with the confirmed or denied decision before the next LLM turn.
+   *
+   * @param invocationContext - The current invocation context, including the
+   *   session event history used to locate pending confirmation responses.
+   * @yields Function response events for tools that have been confirmed and
+   *   are ready to resume.
+   */
   async *runAsync(invocationContext) {
     const agent = invocationContext.agent;
     if (!(0, import_llm_agent.isLlmAgent)(agent)) {

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

@@ -38,7 +38,13 @@ var import_base_llm_processor = require("./base_llm_processor.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class ToolFilterRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
-  /** Filters the set of tools on the request based on plugins. */
+  /**
+   * Invokes plugin-based tool filtering and updates {@link LlmRequest.allowedTools}
+   * with the reduced tool set if any plugin returns a filtered result.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param llmRequest - The request whose allowed tools may be restricted.
+   */
   // eslint-disable-next-line require-yield
   async *runAsync(invocationContext, llmRequest) {
     const agent = invocationContext.agent;

package/dist/cjs/auth/auth_preprocessor.js

@@ -34,6 +34,7 @@ var import_base_llm_processor = require("../agents/processors/base_llm_processor
 var import_readonly_context = require("../agents/readonly_context.js");
 var import_event = require("../events/event.js");
 var import_state = require("../sessions/state.js");
+var import_case_utils = require("../utils/case_utils.js");
 var import_auth_handler = require("./auth_handler.js");
 /**
  * @license
@@ -47,17 +48,15 @@ async function storeAuthAndCollectResumeTargets(events, authFcIds, authResponses
     const eventFunctionCalls = (0, import_event.getFunctionCalls)(event);
     for (const functionCall of eventFunctionCalls) {
       if (functionCall.id && authFcIds.has(functionCall.id) && functionCall.name === import_functions.REQUEST_EUC_FUNCTION_CALL_NAME) {
-        const args = functionCall.args;
-        if (args && args.authConfig) {
-          requestedAuthConfigById[functionCall.id] = args.authConfig;
+        const args = (0, import_case_utils.camelCaseKeys)(functionCall.args);
+        const authConfig = args == null ? void 0 : args.authConfig;
+        if (authConfig) {
+          requestedAuthConfigById[functionCall.id] = authConfig;
         }
       }
     }
   }
   for (const fcId of authFcIds) {
-    if (!(fcId in authResponses)) {
-      continue;
-    }
     const authConfig = authResponses[fcId];
     const requestedAuthConfig = requestedAuthConfigById[fcId];
     if (requestedAuthConfig && requestedAuthConfig.credentialKey) {
@@ -75,12 +74,15 @@ async function storeAuthAndCollectResumeTargets(events, authFcIds, authResponses
       const eventFunctionCalls = (0, import_event.getFunctionCalls)(event);
       for (const functionCall of eventFunctionCalls) {
         if (functionCall.id === fcId && functionCall.name === import_functions.REQUEST_EUC_FUNCTION_CALL_NAME) {
-          const args = functionCall.args;
-          if (args && args.functionCallId) {
-            if (args.functionCallId.startsWith(TOOLSET_AUTH_CREDENTIAL_ID_PREFIX)) {
+          const args = (0, import_case_utils.camelCaseKeys)(
+            functionCall.args
+          );
+          const functionCallId = args == null ? void 0 : args.functionCallId;
+          if (functionCallId) {
+            if (functionCallId.startsWith(TOOLSET_AUTH_CREDENTIAL_ID_PREFIX)) {
               continue;
             }
-            toolsToResume.add(args.functionCallId);
+            toolsToResume.add(functionCallId);
           }
         }
       }

package/dist/cjs/auth/oauth2/oauth2_discovery.js

@@ -172,7 +172,7 @@ function validateDiscoveryUrl(urlStr) {
       return false;
     }
     const host = normaliseHostname(url.hostname.toLowerCase());
-    if (host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host === "0.0.0.0" || host.startsWith("10.") || host.startsWith("192.168.") || host.startsWith("169.254.")) {
+    if (host === "localhost" || host === "metadata.google.internal" || host === "metadata.goog" || host.startsWith("127.") || host === "[::1]" || host === "0.0.0.0" || host.startsWith("10.") || host.startsWith("192.168.") || host.startsWith("169.254.")) {
       import_logger.logger.warn(`Unsafe host for discovery URL: ${host}`);
       return false;
     }