@google/adk 1.1.0 → 1.2.0

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/skill/load_skill_resource_tool.js

@@ -18,34 +18,11 @@ var __decorateClass = (decorators, target, key, kind) => {
 import { Type } from "@google/genai";
 import path from "node:path";
 import { experimental } from "../../utils/experimental.js";
+import { guessMimeType } from "../../utils/file_utils.js";
 import {
   BaseTool
 } from "../base_tool.js";
 const BINARY_FILE_DETECTED_MSG = "Binary file detected. The content has been injected into the conversation history for you to analyze.";
-const EXTENSION_TO_MIME_TYPE = {
-  "pdf": "application/pdf",
-  "jpg": "image/jpeg",
-  "jpeg": "image/jpeg",
-  "png": "image/png",
-  "gif": "image/gif",
-  "csv": "text/csv",
-  "json": "application/json",
-  "xml": "application/xml",
-  "sh": "text/x-shellscript",
-  "bash": "text/x-shellscript",
-  "py": "text/x-python",
-  "js": "text/javascript",
-  "cjs": "text/javascript",
-  "mjs": "text/javascript",
-  "ts": "text/javascript",
-  "cts": "text/javascript",
-  "mts": "text/javascript"
-};
-function guessMimeType(filePath) {
-  var _a;
-  const ext = ((_a = filePath.split(".").pop()) == null ? void 0 : _a.toLowerCase()) || "";
-  return EXTENSION_TO_MIME_TYPE[ext] || "application/octet-stream";
-}
 let LoadSkillResourceTool = class extends BaseTool {
   constructor(toolset) {
     super({

package/dist/web/tools/vertex_rag_retrieval_tool.js

@@ -0,0 +1,36 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseTool } from "./base_tool.js";
+class VertexRagRetrievalTool extends BaseTool {
+  constructor(config) {
+    super({
+      name: "vertex_rag_retrieval",
+      description: "Vertex AI RAG Retrieval Tool"
+    });
+    this.vertexRagStore = config;
+  }
+  /**
+   * This tool is executed server-side by the Vertex AI RAG Engine.
+   * Local execution is not required.
+   */
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    llmRequest.config = llmRequest.config || {};
+    llmRequest.config.tools = llmRequest.config.tools || [];
+    llmRequest.config.tools.push({
+      retrieval: { vertexRagStore: this.vertexRagStore }
+    });
+  }
+}
+export {
+  VertexRagRetrievalTool
+};

package/dist/web/utils/file_utils.js

@@ -69,6 +69,32 @@ async function materializeFiles(files, dir = process.cwd()) {
   }
   return createdFiles;
 }
+const EXTENSION_TO_MIME_TYPE = {
+  "pdf": "application/pdf",
+  "jpg": "image/jpeg",
+  "jpeg": "image/jpeg",
+  "png": "image/png",
+  "gif": "image/gif",
+  "csv": "text/csv",
+  "json": "application/json",
+  "xml": "application/xml",
+  "sh": "text/x-shellscript",
+  "bash": "text/x-shellscript",
+  "py": "text/x-python",
+  "js": "text/javascript",
+  "cjs": "text/javascript",
+  "mjs": "text/javascript",
+  "ts": "text/javascript",
+  "cts": "text/javascript",
+  "mts": "text/javascript"
+};
+function guessMimeType(filePath) {
+  var _a;
+  const ext = ((_a = filePath.split(".").pop()) == null ? void 0 : _a.toLowerCase()) || "";
+  return EXTENSION_TO_MIME_TYPE[ext] || "application/octet-stream";
+}
 export {
+  EXTENSION_TO_MIME_TYPE,
+  guessMimeType,
   materializeFiles
 };

package/dist/web/utils/gemini_schema_util.js

@@ -112,6 +112,21 @@ function toGeminiSchema(mcpSchema) {
         mcp.type = "array";
       } else if (isNullable) {
         mcp.type = "null";
+      } else if (mcp.enum) {
+        const enumTypes = new Set(mcp.enum.map((v) => typeof v));
+        if (enumTypes.size === 1) {
+          const jsType = [...enumTypes][0];
+          if (jsType === "string") mcp.type = "string";
+          else if (jsType === "number") mcp.type = "number";
+          else if (jsType === "boolean") mcp.type = "boolean";
+        }
+      } else if (mcp.const !== void 0) {
+        const jsType = typeof mcp.const;
+        let inferredType;
+        if (jsType === "string") inferredType = "string";
+        else if (jsType === "number") inferredType = "number";
+        else if (jsType === "boolean") inferredType = "boolean";
+        mcp = __spreadProps(__spreadValues({}, mcp), { type: inferredType, enum: [mcp.const] });
       }
     }
     const geminiType = toGeminiType(mcp.type);
@@ -126,6 +141,9 @@ function toGeminiSchema(mcpSchema) {
     if (mcp.description) {
       geminiSchema.description = mcp.description;
     }
+    if (mcp.enum) {
+      geminiSchema.enum = mcp.enum.map(String);
+    }
     if (isNullable && mcp.type !== "null") {
       geminiSchema.nullable = true;
     }

package/dist/web/utils/partial_copy.js

@@ -0,0 +1,23 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function partialCopy(source, targetKeys) {
+  const result = {};
+  const sourceAsUnknown = source;
+  targetKeys.forEach((key) => {
+    const keyStr = key;
+    if (keyStr in source) {
+      result[key] = sourceAsUnknown[keyStr];
+    } else {
+      result[key] = void 0;
+    }
+  });
+  return result;
+}
+export {
+  partialCopy
+};