@google/adk 1.1.0 → 1.3.0

package/dist/web/tools/google_maps_grounding_tool.js

@@ -0,0 +1,54 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  isGemini1Model,
+  isGeminiModel,
+  isGeminiModelIdCheckDisabled
+} from "../utils/model_name.js";
+import { BaseTool } from "./base_tool.js";
+function applyGoogleMapsGrounding(llmRequest) {
+  if (!llmRequest.model) {
+    return;
+  }
+  const modelCheckDisabled = isGeminiModelIdCheckDisabled();
+  llmRequest.config = llmRequest.config || {};
+  llmRequest.config.tools = llmRequest.config.tools || [];
+  if (isGemini1Model(llmRequest.model)) {
+    throw new Error(
+      "Google Maps grounding tool cannot be used with Gemini 1.x models."
+    );
+  }
+  if (isGeminiModel(llmRequest.model) || modelCheckDisabled) {
+    llmRequest.config.tools.push({
+      googleMaps: {}
+    });
+    return;
+  }
+  throw new Error(
+    "Google maps tool is not supported for model ".concat(llmRequest.model)
+  );
+}
+class GoogleMapsGroundingTool extends 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();
+export {
+  GOOGLE_MAPS_GROUNDING,
+  GoogleMapsGroundingTool,
+  applyGoogleMapsGrounding
+};

package/dist/web/tools/long_running_tool.js

@@ -37,7 +37,8 @@ class LongRunningFunctionTool extends FunctionTool {
     super(__spreadProps(__spreadValues({}, 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/web/tools/mcp/mcp_session_manager.js

@@ -14,6 +14,7 @@ import {
 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 class MCPSessionManager {
   constructor(connectionParams) {
+    this.activeSessions = /* @__PURE__ */ new Set();
     this.connectionParams = connectionParams;
   }
   async createSession() {
@@ -45,8 +46,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);
+  }
 }
 export {
   MCPSessionManager

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

@@ -26,12 +26,16 @@ class MCPTool extends 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);
+    }
   }
 }
 export {

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

@@ -33,21 +33,44 @@ class MCPToolset extends BaseToolset {
     super(toolFilter, prefix);
     this.mcpSessionManager = new 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);
+    }
     logger.debug("number of tools: ".concat(listResult.tools.length));
     for (const tool of listResult.tools) {
       logger.debug("tool: ".concat(tool.name));
     }
-    return listResult.tools.map((tool) => {
+    const tools = listResult.tools.map((tool) => {
       const toolWithPrefix = __spreadProps(__spreadValues({}, tool), {
         name: this.prefix ? "".concat(this.prefix, "_").concat(tool.name) : tool.name
       });
       return new 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));
+    }
+    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))
+    );
   }
 }
 export {

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

@@ -0,0 +1,48 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @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 += "".concat(separator).concat(name, "=").concat(encodeURIComponent(credential.apiKey));
+    } else {
+      headers["Authorization"] = credential.apiKey;
+    }
+  } else if (credential.http && credential.http.credentials && credential.http.credentials.token) {
+    headers["Authorization"] = "Bearer ".concat(credential.http.credentials.token);
+  }
+  return url;
+}
+function createApiKeyScheme(name, inLocation) {
+  return {
+    type: "apiKey",
+    name,
+    in: inLocation
+  };
+}
+function createBearerScheme() {
+  return {
+    type: "http",
+    scheme: "bearer"
+  };
+}
+export {
+  applyCredential,
+  createApiKeyScheme,
+  createBearerScheme
+};

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

@@ -0,0 +1,60 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  AuthCredentialTypes
+} from "../../../../auth/auth_credential.js";
+import { OAuth2CredentialExchanger } from "../../../../auth/oauth2/oauth2_credential_exchanger.js";
+import { experimental } from "../../../../utils/experimental.js";
+import { ServiceAccountCredentialExchanger } from "./service_account_exchanger.js";
+let AutoAuthCredentialExchanger = class {
+  constructor() {
+    this.exchangers = /* @__PURE__ */ new Map();
+    this.exchangers.set(
+      AuthCredentialTypes.OAUTH2,
+      new OAuth2CredentialExchanger()
+    );
+    this.exchangers.set(
+      AuthCredentialTypes.OPEN_ID_CONNECT,
+      new OAuth2CredentialExchanger()
+    );
+    this.exchangers.set(
+      AuthCredentialTypes.SERVICE_ACCOUNT,
+      new 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([
+  experimental
+], AutoAuthCredentialExchanger.prototype, "exchange", 1);
+AutoAuthCredentialExchanger = __decorateClass([
+  experimental
+], AutoAuthCredentialExchanger);
+export {
+  AutoAuthCredentialExchanger
+};

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

@@ -0,0 +1,111 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GoogleAuth, JWT } from "google-auth-library";
+import {
+  AuthCredentialTypes
+} from "../../../../auth/auth_credential.js";
+import {
+  CredentialExchangeError
+} from "../../../../auth/exchanger/base_credential_exchanger.js";
+import { experimental } from "../../../../utils/experimental.js";
+const DEFAULT_SCOPES = ["https://www.googleapis.com/auth/cloud-platform"];
+let ServiceAccountCredentialExchanger = class {
+  async exchange(params) {
+    const { authCredential } = params;
+    if (authCredential.authType !== AuthCredentialTypes.SERVICE_ACCOUNT || !authCredential.serviceAccount) {
+      throw new 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 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: AuthCredentialTypes.HTTP,
+          http: {
+            scheme: "bearer",
+            credentials: { token }
+          }
+        },
+        wasExchanged: true
+      };
+    } catch (error) {
+      throw new CredentialExchangeError(
+        "Failed to exchange default service account token: ".concat(error.message)
+      );
+    }
+  }
+  async exchangeForExplicitCredential(saConfig) {
+    const creds = saConfig.serviceAccountCredential;
+    if (!creds) {
+      throw new CredentialExchangeError(
+        "Service account credentials are missing."
+      );
+    }
+    try {
+      const client = new 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: AuthCredentialTypes.HTTP,
+          http: {
+            scheme: "bearer",
+            credentials: { token }
+          }
+        },
+        wasExchanged: true
+      };
+    } catch (error) {
+      throw new CredentialExchangeError(
+        "Failed to exchange explicit service account token: ".concat(error.message)
+      );
+    }
+  }
+};
+__decorateClass([
+  experimental
+], ServiceAccountCredentialExchanger.prototype, "exchange", 1);
+ServiceAccountCredentialExchanger = __decorateClass([
+  experimental
+], ServiceAccountCredentialExchanger);
+export {
+  ServiceAccountCredentialExchanger
+};

package/dist/web/tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.js

@@ -0,0 +1,221 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+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;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { experimental } from "../../../utils/experimental.js";
+import { OperationParser } from "./operation_parser.js";
+const VALID_SCHEMA_TYPES = /* @__PURE__ */ new Set([
+  "array",
+  "boolean",
+  "integer",
+  "null",
+  "number",
+  "object",
+  "string"
+]);
+let OpenApiSpecParser = class {
+  constructor(options = {}) {
+    var _a;
+    this.preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
+  }
+  parse(openapiSpec) {
+    const resolvedSpec = resolveReferences(openapiSpec);
+    const sanitizedSpec = sanitizeSchemaTypes(resolvedSpec);
+    return collectOperations(sanitizedSpec, {
+      preservePropertyNames: this.preservePropertyNames
+    });
+  }
+};
+__decorateClass([
+  experimental
+], OpenApiSpecParser.prototype, "parse", 1);
+OpenApiSpecParser = __decorateClass([
+  experimental
+], OpenApiSpecParser);
+function resolveReferences(spec) {
+  const resolvedCache = /* @__PURE__ */ new Map();
+  const specCopy = JSON.parse(JSON.stringify(spec));
+  const recursiveResolve = (obj, currentDoc, seenRefs = /* @__PURE__ */ new Set()) => {
+    if (typeof obj !== "object" || obj === null) {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => recursiveResolve(item, currentDoc, seenRefs));
+    }
+    const objRecord = obj;
+    if ("$ref" in objRecord && typeof objRecord["$ref"] === "string") {
+      const refString = objRecord["$ref"];
+      if (seenRefs.has(refString) && !resolvedCache.has(refString)) {
+        const copy = __spreadValues({}, objRecord);
+        delete copy["$ref"];
+        return copy;
+      }
+      seenRefs.add(refString);
+      if (resolvedCache.has(refString)) {
+        return resolvedCache.get(refString);
+      }
+      let resolvedValue = resolveRef(refString, currentDoc);
+      if (resolvedValue !== void 0) {
+        resolvedValue = recursiveResolve(resolvedValue, currentDoc, seenRefs);
+        resolvedCache.set(refString, resolvedValue);
+        return resolvedValue;
+      } else {
+        return obj;
+      }
+    }
+    const newDict = {};
+    for (const [key, value] of Object.entries(objRecord)) {
+      newDict[key] = recursiveResolve(value, currentDoc, seenRefs);
+    }
+    return newDict;
+  };
+  return recursiveResolve(specCopy, specCopy);
+}
+function resolveRef(refString, currentDoc) {
+  const parts = refString.split("/");
+  if (parts[0] !== "#") {
+    throw new Error("External references not supported: ".concat(refString));
+  }
+  let current = currentDoc;
+  for (const part of parts.slice(1)) {
+    if (typeof current === "object" && current !== null && part in current) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function sanitizeSchemaTypes(openapiSpec) {
+  const specCopy = JSON.parse(JSON.stringify(openapiSpec));
+  const sanitizeTypeField = (schemaDict) => {
+    if (!("type" in schemaDict)) return;
+    const typeValue = schemaDict["type"];
+    if (typeof typeValue === "string") {
+      const normalizedType = typeValue.toLowerCase();
+      if (VALID_SCHEMA_TYPES.has(normalizedType)) {
+        schemaDict["type"] = normalizedType;
+      } else {
+        delete schemaDict["type"];
+      }
+      return;
+    }
+    if (Array.isArray(typeValue)) {
+      const validTypes = [];
+      for (const entry of typeValue) {
+        if (typeof entry !== "string") continue;
+        const normalizedEntry = entry.toLowerCase();
+        if (VALID_SCHEMA_TYPES.has(normalizedEntry) && !validTypes.includes(normalizedEntry)) {
+          validTypes.push(normalizedEntry);
+        }
+      }
+      if (validTypes.length > 0) {
+        schemaDict["type"] = validTypes;
+      } else {
+        delete schemaDict["type"];
+      }
+    }
+  };
+  const sanitizeRecursive = (obj, inSchema) => {
+    if (typeof obj !== "object" || obj === null) {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => sanitizeRecursive(item, inSchema));
+    }
+    const objRecord = obj;
+    if (inSchema) {
+      sanitizeTypeField(objRecord);
+    }
+    for (const [key, value] of Object.entries(objRecord)) {
+      const isSchemaContainer = key === "schema" || key === "schemas";
+      objRecord[key] = sanitizeRecursive(value, inSchema || isSchemaContainer);
+    }
+    return objRecord;
+  };
+  return sanitizeRecursive(specCopy, false);
+}
+function collectOperations(spec, options = {}) {
+  var _a, _b, _c, _d;
+  const preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
+  const operations = [];
+  const baseUrl = ((_c = (_b = spec.servers) == null ? void 0 : _b[0]) == null ? void 0 : _c.url) || "";
+  const globalSecurity = spec.security || [];
+  let globalSchemeName;
+  if (globalSecurity.length > 0) {
+    globalSchemeName = Object.keys(globalSecurity[0])[0];
+  }
+  const authSchemes = ((_d = spec.components) == null ? void 0 : _d.securitySchemes) || {};
+  for (const [path, pathItem] of Object.entries(spec.paths || {})) {
+    if (!pathItem) continue;
+    const methods = [
+      "get",
+      "post",
+      "put",
+      "delete",
+      "patch",
+      "head",
+      "options",
+      "trace"
+    ];
+    for (const method of methods) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const pathParams = pathItem.parameters || [];
+      const opParams = operation.parameters || [];
+      operation.parameters = [...opParams, ...pathParams];
+      if (!operation.operationId) {
+        operation.operationId = "".concat(method, "_").concat(path.replace(/[^a-zA-Z0-9]/g, "_"));
+      }
+      const parser = new OperationParser(operation, {
+        preservePropertyNames
+      });
+      let authSchemeName;
+      if (operation.security && operation.security.length > 0) {
+        authSchemeName = Object.keys(operation.security[0])[0];
+      }
+      authSchemeName = authSchemeName || globalSchemeName;
+      const authScheme = authSchemeName ? authSchemes[authSchemeName] : void 0;
+      operations.push({
+        name: parser.getFunctionName(),
+        description: parser.getDescription(),
+        endpoint: { baseUrl, path, method },
+        operation,
+        parameters: parser.getParameters(),
+        authScheme
+      });
+    }
+  }
+  return operations;
+}
+export {
+  OpenApiSpecParser
+};