@google/adk 1.1.0 → 1.3.0

package/dist/cjs/tools/exit_loop_tool.js

@@ -35,18 +35,27 @@ var import_base_tool = require("./base_tool.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class ExitLoopTool extends import_base_tool.BaseTool {
+  /** Creates an ExitLoopTool with its fixed name and description. */
   constructor() {
     super({
       name: "exit_loop",
       description: "Exits the loop.\n\nCall this function only when you are instructed to do so."
     });
   }
+  /** Returns the function declaration for this tool. */
   _getDeclaration() {
     return {
       name: this.name,
       description: this.description
     };
   }
+  /**
+   * Sets `escalate` and `skipSummarization` on the event actions, signalling
+   * the {@link LoopAgent} to stop iterating.
+   *
+   * @param request The tool request containing the current tool context.
+   * @returns An empty string response.
+   */
   async runAsync({
     toolContext
   }) {

package/dist/cjs/tools/function_tool.js

@@ -74,7 +74,8 @@ class FunctionTool extends (_b = import_base_tool.BaseTool, _a = FUNCTION_TOOL_S
     this.parameters = options.parameters;
   }
   /**
-   * Provide a schema for the function.
+   * Returns the function declaration derived from the tool's name, description,
+   * and parameter schema.
    */
   _getDeclaration() {
     return {
@@ -84,7 +85,11 @@ class FunctionTool extends (_b = import_base_tool.BaseTool, _a = FUNCTION_TOOL_S
     };
   }
   /**
-   * Logic for running the tool.
+   * Validates the model-provided arguments against the parameter schema and
+   * invokes the user-defined `execute` function.
+   *
+   * @param req The tool request containing arguments and tool context.
+   * @returns A promise resolving to the function's return value.
    */
   async runAsync(req) {
     try {

package/dist/cjs/tools/google_maps_grounding_tool.js

@@ -0,0 +1,80 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var google_maps_grounding_tool_exports = {};
+__export(google_maps_grounding_tool_exports, {
+  GOOGLE_MAPS_GROUNDING: () => GOOGLE_MAPS_GROUNDING,
+  GoogleMapsGroundingTool: () => GoogleMapsGroundingTool,
+  applyGoogleMapsGrounding: () => applyGoogleMapsGrounding
+});
+module.exports = __toCommonJS(google_maps_grounding_tool_exports);
+var import_model_name = require("../utils/model_name.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function applyGoogleMapsGrounding(llmRequest) {
+  if (!llmRequest.model) {
+    return;
+  }
+  const modelCheckDisabled = (0, import_model_name.isGeminiModelIdCheckDisabled)();
+  llmRequest.config = llmRequest.config || {};
+  llmRequest.config.tools = llmRequest.config.tools || [];
+  if ((0, import_model_name.isGemini1Model)(llmRequest.model)) {
+    throw new Error(
+      "Google Maps grounding tool cannot be used with Gemini 1.x models."
+    );
+  }
+  if ((0, import_model_name.isGeminiModel)(llmRequest.model) || modelCheckDisabled) {
+    llmRequest.config.tools.push({
+      googleMaps: {}
+    });
+    return;
+  }
+  throw new Error(
+    `Google maps tool is not supported for model ${llmRequest.model}`
+  );
+}
+class GoogleMapsGroundingTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({ name: "google_maps", description: "Google Maps Grounding Tool" });
+  }
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    applyGoogleMapsGrounding(llmRequest);
+  }
+}
+const GOOGLE_MAPS_GROUNDING = new GoogleMapsGroundingTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GOOGLE_MAPS_GROUNDING,
+  GoogleMapsGroundingTool,
+  applyGoogleMapsGrounding
+});

package/dist/cjs/tools/long_running_tool.js

@@ -45,7 +45,8 @@ class LongRunningFunctionTool extends import_function_tool.FunctionTool {
     super({ ...options, isLongRunning: true });
   }
   /**
-   * Provide a schema for the function.
+   * Returns the function declaration with an appended instruction warning the
+   * model not to re-invoke the tool while it is still running.
    */
   _getDeclaration() {
     const declaration = super._getDeclaration();

package/dist/cjs/tools/mcp/mcp_session_manager.js

@@ -37,6 +37,7 @@ var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamable
  */
 class MCPSessionManager {
   constructor(connectionParams) {
+    this.activeSessions = /* @__PURE__ */ new Set();
     this.connectionParams = connectionParams;
   }
   async createSession() {
@@ -68,8 +69,18 @@ class MCPSessionManager {
         break;
       }
     }
+    this.activeSessions.add(client);
     return client;
   }
+  async closeSession(client) {
+    if (this.activeSessions.has(client)) {
+      this.activeSessions.delete(client);
+      await client.close();
+    }
+  }
+  getActiveSessions() {
+    return Array.from(this.activeSessions);
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/tools/mcp/mcp_tool.js

@@ -53,12 +53,16 @@ class MCPTool extends import_base_tool.BaseTool {
   }
   async runAsync(request) {
     const session = await this.mcpSessionManager.createSession();
-    const callRequest = {};
-    callRequest.params = { name: this.originalName, arguments: request.args };
-    const result = await session.callTool(callRequest.params, void 0, {
-      signal: request.toolContext.abortSignal
-    });
-    return result;
+    try {
+      const callRequest = {};
+      callRequest.params = { name: this.originalName, arguments: request.args };
+      const result = await session.callTool(callRequest.params, void 0, {
+        signal: request.toolContext.abortSignal
+      });
+      return result;
+    } finally {
+      await this.mcpSessionManager.closeSession(session);
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/tools/mcp/mcp_toolset.js

@@ -41,22 +41,45 @@ class MCPToolset extends import_base_toolset.BaseToolset {
     super(toolFilter, prefix);
     this.mcpSessionManager = new import_mcp_session_manager.MCPSessionManager(connectionParams);
   }
-  async getTools() {
+  async getTools(context) {
     const session = await this.mcpSessionManager.createSession();
-    const listResult = await session.listTools();
+    let listResult;
+    try {
+      listResult = await session.listTools();
+    } finally {
+      await this.mcpSessionManager.closeSession(session);
+    }
     import_logger.logger.debug(`number of tools: ${listResult.tools.length}`);
     for (const tool of listResult.tools) {
       import_logger.logger.debug(`tool: ${tool.name}`);
     }
-    return listResult.tools.map((tool) => {
+    const tools = listResult.tools.map((tool) => {
       const toolWithPrefix = {
         ...tool,
         name: this.prefix ? `${this.prefix}_${tool.name}` : tool.name
       };
       return new import_mcp_tool.MCPTool(toolWithPrefix, this.mcpSessionManager, tool.name);
     });
+    const filter = this.toolFilter;
+    if (!filter || Array.isArray(filter) && filter.length === 0) {
+      return tools;
+    }
+    if (Array.isArray(filter)) {
+      return tools.filter((tool) => filter.includes(tool.name));
+    }
+    if (context) {
+      return tools.filter((tool) => filter(tool, context));
+    }
+    import_logger.logger.warn(
+      "MCPToolset: a ToolPredicate toolFilter was provided but getTools() was called without a ReadonlyContext. The filter will not be applied."
+    );
+    return tools;
   }
   async close() {
+    const sessions = this.mcpSessionManager.getActiveSessions();
+    await Promise.allSettled(
+      sessions.map((session) => this.mcpSessionManager.closeSession(session))
+    );
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/tools/openapi_tool/auth/auth_helpers.js

@@ -0,0 +1,78 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var auth_helpers_exports = {};
+__export(auth_helpers_exports, {
+  applyCredential: () => applyCredential,
+  createApiKeyScheme: () => createApiKeyScheme,
+  createBearerScheme: () => createBearerScheme
+});
+module.exports = __toCommonJS(auth_helpers_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function applyCredential(url, headers, credential, authScheme) {
+  if (!credential) return url;
+  if (credential.apiKey) {
+    let inLocation;
+    let name = "key";
+    if (authScheme && authScheme.type === "apiKey") {
+      const apiKeyScheme = authScheme;
+      inLocation = apiKeyScheme.in;
+      name = apiKeyScheme.name;
+    }
+    if (inLocation === "header") {
+      headers[name] = credential.apiKey;
+    } else if (inLocation === "query") {
+      const separator = url.includes("?") ? "&" : "?";
+      url += `${separator}${name}=${encodeURIComponent(credential.apiKey)}`;
+    } else {
+      headers["Authorization"] = credential.apiKey;
+    }
+  } else if (credential.http && credential.http.credentials && credential.http.credentials.token) {
+    headers["Authorization"] = `Bearer ${credential.http.credentials.token}`;
+  }
+  return url;
+}
+function createApiKeyScheme(name, inLocation) {
+  return {
+    type: "apiKey",
+    name,
+    in: inLocation
+  };
+}
+function createBearerScheme() {
+  return {
+    type: "http",
+    scheme: "bearer"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyCredential,
+  createApiKeyScheme,
+  createBearerScheme
+});

package/dist/cjs/tools/openapi_tool/auth/credential_exchangers/auto_auth_credential_exchanger.js

@@ -0,0 +1,84 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var auto_auth_credential_exchanger_exports = {};
+__export(auto_auth_credential_exchanger_exports, {
+  AutoAuthCredentialExchanger: () => AutoAuthCredentialExchanger
+});
+module.exports = __toCommonJS(auto_auth_credential_exchanger_exports);
+var import_auth_credential = require("../../../../auth/auth_credential.js");
+var import_oauth2_credential_exchanger = require("../../../../auth/oauth2/oauth2_credential_exchanger.js");
+var import_experimental = require("../../../../utils/experimental.js");
+var import_service_account_exchanger = require("./service_account_exchanger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let AutoAuthCredentialExchanger = class {
+  constructor() {
+    this.exchangers = /* @__PURE__ */ new Map();
+    this.exchangers.set(
+      import_auth_credential.AuthCredentialTypes.OAUTH2,
+      new import_oauth2_credential_exchanger.OAuth2CredentialExchanger()
+    );
+    this.exchangers.set(
+      import_auth_credential.AuthCredentialTypes.OPEN_ID_CONNECT,
+      new import_oauth2_credential_exchanger.OAuth2CredentialExchanger()
+    );
+    this.exchangers.set(
+      import_auth_credential.AuthCredentialTypes.SERVICE_ACCOUNT,
+      new import_service_account_exchanger.ServiceAccountCredentialExchanger()
+    );
+  }
+  async exchange(params) {
+    const { authCredential, authScheme } = params;
+    const exchanger = this.exchangers.get(authCredential.authType);
+    if (!exchanger) {
+      return {
+        credential: authCredential,
+        wasExchanged: false
+      };
+    }
+    return exchanger.exchange({ authScheme, authCredential });
+  }
+};
+__decorateClass([
+  import_experimental.experimental
+], AutoAuthCredentialExchanger.prototype, "exchange", 1);
+AutoAuthCredentialExchanger = __decorateClass([
+  import_experimental.experimental
+], AutoAuthCredentialExchanger);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AutoAuthCredentialExchanger
+});

package/dist/cjs/tools/openapi_tool/auth/credential_exchangers/service_account_exchanger.js

@@ -0,0 +1,133 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var service_account_exchanger_exports = {};
+__export(service_account_exchanger_exports, {
+  ServiceAccountCredentialExchanger: () => ServiceAccountCredentialExchanger
+});
+module.exports = __toCommonJS(service_account_exchanger_exports);
+var import_google_auth_library = require("google-auth-library");
+var import_auth_credential = require("../../../../auth/auth_credential.js");
+var import_base_credential_exchanger = require("../../../../auth/exchanger/base_credential_exchanger.js");
+var import_experimental = require("../../../../utils/experimental.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const DEFAULT_SCOPES = ["https://www.googleapis.com/auth/cloud-platform"];
+let ServiceAccountCredentialExchanger = class {
+  async exchange(params) {
+    const { authCredential } = params;
+    if (authCredential.authType !== import_auth_credential.AuthCredentialTypes.SERVICE_ACCOUNT || !authCredential.serviceAccount) {
+      throw new import_base_credential_exchanger.CredentialExchangeError(
+        "Invalid credential type for ServiceAccountCredentialExchanger"
+      );
+    }
+    const saConfig = authCredential.serviceAccount;
+    if (saConfig.useDefaultCredential) {
+      return this.exchangeForDefaultCredential(saConfig);
+    }
+    return this.exchangeForExplicitCredential(saConfig);
+  }
+  async exchangeForDefaultCredential(saConfig) {
+    try {
+      const auth = new import_google_auth_library.GoogleAuth({
+        scopes: saConfig.scopes || DEFAULT_SCOPES
+      });
+      const client = await auth.getClient();
+      const tokenResponse = await client.getAccessToken();
+      const token = tokenResponse.token;
+      if (!token) {
+        throw new Error("Failed to get access token from default credentials");
+      }
+      return {
+        credential: {
+          authType: import_auth_credential.AuthCredentialTypes.HTTP,
+          http: {
+            scheme: "bearer",
+            credentials: { token }
+          }
+        },
+        wasExchanged: true
+      };
+    } catch (error) {
+      throw new import_base_credential_exchanger.CredentialExchangeError(
+        `Failed to exchange default service account token: ${error.message}`
+      );
+    }
+  }
+  async exchangeForExplicitCredential(saConfig) {
+    const creds = saConfig.serviceAccountCredential;
+    if (!creds) {
+      throw new import_base_credential_exchanger.CredentialExchangeError(
+        "Service account credentials are missing."
+      );
+    }
+    try {
+      const client = new import_google_auth_library.JWT({
+        email: creds.clientEmail,
+        key: creds.privateKey,
+        scopes: saConfig.scopes
+      });
+      const tokens = await client.authorize();
+      const token = tokens.access_token;
+      if (!token) {
+        throw new Error("Failed to get access token from explicit credentials");
+      }
+      return {
+        credential: {
+          authType: import_auth_credential.AuthCredentialTypes.HTTP,
+          http: {
+            scheme: "bearer",
+            credentials: { token }
+          }
+        },
+        wasExchanged: true
+      };
+    } catch (error) {
+      throw new import_base_credential_exchanger.CredentialExchangeError(
+        `Failed to exchange explicit service account token: ${error.message}`
+      );
+    }
+  }
+};
+__decorateClass([
+  import_experimental.experimental
+], ServiceAccountCredentialExchanger.prototype, "exchange", 1);
+ServiceAccountCredentialExchanger = __decorateClass([
+  import_experimental.experimental
+], ServiceAccountCredentialExchanger);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServiceAccountCredentialExchanger
+});