@google/adk 2.3.0 → 2.5.0

package/dist/cjs/tools/google_api_tool/google_api_toolset.js

@@ -0,0 +1,174 @@
+/**
+  * @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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 google_api_toolset_exports = {};
+__export(google_api_toolset_exports, {
+  GoogleApiToolset: () => GoogleApiToolset,
+  isGoogleApiToolset: () => isGoogleApiToolset
+});
+module.exports = __toCommonJS(google_api_toolset_exports);
+var import_experimental = require("../../utils/experimental.js");
+var import_base_toolset = require("../base_toolset.js");
+var import_openapi_toolset = require("../openapi_tool/openapi_toolset.js");
+var import_google_api_tool = require("./google_api_tool.js");
+var import_googleapi_to_openapi_converter = require("./googleapi_to_openapi_converter.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.googleApiToolset"
+);
+const GOOGLE_OIDC_AUTH_ENDPOINT = "https://accounts.google.com/o/oauth2/v2/auth";
+const GOOGLE_OIDC_TOKEN_ENDPOINT = "https://oauth2.googleapis.com/token";
+const GOOGLE_OIDC_USERINFO_ENDPOINT = "https://openidconnect.googleapis.com/v1/userinfo";
+const GOOGLE_OIDC_REVOCATION_ENDPOINT = "https://oauth2.googleapis.com/revoke";
+function isGoogleApiToolset(obj) {
+  return typeof obj === "object" && obj !== null && GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL in obj && obj[GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL] === true;
+}
+__name(isGoogleApiToolset, "isGoogleApiToolset");
+let GoogleApiToolset = class extends (_b = import_base_toolset.BaseToolset, _a = GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL, _b) {
+  constructor(options = {}) {
+    var _a2;
+    const toolFilter = (_a2 = options.toolFilter) != null ? _a2 : [];
+    super(toolFilter);
+    this[_a] = true;
+    this.tools = [];
+    this.toolFilter = toolFilter;
+    this.apiName = options.apiName;
+    this.apiVersion = options.apiVersion;
+    this.clientId = options.clientId;
+    this.clientSecret = options.clientSecret;
+    this.scopes = options.scopes ? [...options.scopes] : void 0;
+  }
+  async loadToolsetWithOidcAuth() {
+    var _a2, _b2, _c, _d, _e;
+    if (!this.apiName || !this.apiVersion) {
+      throw new Error(
+        "Both apiName and apiVersion are required to load a GoogleApiToolset."
+      );
+    }
+    const specDict = await new import_googleapi_to_openapi_converter.GoogleApiToOpenApiConverter(
+      this.apiName,
+      this.apiVersion
+    ).convert();
+    const oauth2Scheme = (_b2 = (_a2 = specDict.components) == null ? void 0 : _a2.securitySchemes) == null ? void 0 : _b2["oauth2"];
+    const scopesMap = (_e = (_d = (_c = oauth2Scheme == null ? void 0 : oauth2Scheme.flows) == null ? void 0 : _c.authorizationCode) == null ? void 0 : _d.scopes) != null ? _e : {};
+    const firstScope = Object.keys(scopesMap)[0];
+    const scopes = this.scopes !== void 0 ? [...this.scopes] : firstScope ? [firstScope] : void 0;
+    const authScheme = {
+      type: "openIdConnect",
+      openIdConnectUrl: "",
+      authorizationEndpoint: GOOGLE_OIDC_AUTH_ENDPOINT,
+      tokenEndpoint: GOOGLE_OIDC_TOKEN_ENDPOINT,
+      userinfoEndpoint: GOOGLE_OIDC_USERINFO_ENDPOINT,
+      revocationEndpoint: GOOGLE_OIDC_REVOCATION_ENDPOINT,
+      tokenEndpointAuthMethodsSupported: [
+        "client_secret_post",
+        "client_secret_basic"
+      ],
+      grantTypesSupported: ["authorization_code"],
+      scopes
+    };
+    return new import_openapi_toolset.OpenAPIToolset({
+      specDict,
+      specType: "yaml",
+      authScheme
+    });
+  }
+  async ensureToolsLoaded() {
+    var _a2;
+    if (this.openapiToolset) {
+      return;
+    }
+    (_a2 = this.loadingPromise) != null ? _a2 : this.loadingPromise = (async () => {
+      try {
+        const openapiToolset = await this.loadToolsetWithOidcAuth();
+        const restTools = await openapiToolset.getTools();
+        this.tools = restTools.map(
+          (tool) => new import_google_api_tool.GoogleApiTool(tool, {
+            clientId: this.clientId,
+            clientSecret: this.clientSecret
+          })
+        );
+        this.openapiToolset = openapiToolset;
+      } catch (error) {
+        this.loadingPromise = void 0;
+        throw error;
+      }
+    })();
+    await this.loadingPromise;
+  }
+  async getTools(context) {
+    await this.ensureToolsLoaded();
+    return this.tools.filter((tool) => this.isToolSelected(tool, context));
+  }
+  setToolFilter(toolFilter) {
+    this.toolFilter = toolFilter;
+  }
+  configureAuth(clientId, clientSecret) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    for (const tool of this.tools) {
+      tool.configureAuth(clientId, clientSecret);
+    }
+  }
+  async close() {
+    if (this.openapiToolset) {
+      await this.openapiToolset.close();
+    }
+  }
+};
+__name(GoogleApiToolset, "GoogleApiToolset");
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToolset.prototype, "getTools", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToolset.prototype, "setToolFilter", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToolset.prototype, "configureAuth", 1);
+__decorateClass([
+  import_experimental.experimental
+], GoogleApiToolset.prototype, "close", 1);
+GoogleApiToolset = __decorateClass([
+  import_experimental.experimental
+], GoogleApiToolset);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GoogleApiToolset,
+  isGoogleApiToolset
+});

package/dist/cjs/tools/google_api_tool/google_api_toolsets.js

@@ -0,0 +1,124 @@
+/**
+  * @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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 google_api_toolsets_exports = {};
+__export(google_api_toolsets_exports, {
+  BigQueryToolset: () => BigQueryToolset,
+  CalendarToolset: () => CalendarToolset,
+  DocsToolset: () => DocsToolset,
+  GmailToolset: () => GmailToolset,
+  SheetsToolset: () => SheetsToolset,
+  SlidesToolset: () => SlidesToolset,
+  YoutubeToolset: () => YoutubeToolset
+});
+module.exports = __toCommonJS(google_api_toolsets_exports);
+var import_experimental = require("../../utils/experimental.js");
+var import_google_api_toolset = require("./google_api_toolset.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let BigQueryToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "bigquery", apiVersion: "v2" });
+  }
+};
+__name(BigQueryToolset, "BigQueryToolset");
+BigQueryToolset = __decorateClass([
+  import_experimental.experimental
+], BigQueryToolset);
+let CalendarToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "calendar", apiVersion: "v3" });
+  }
+};
+__name(CalendarToolset, "CalendarToolset");
+CalendarToolset = __decorateClass([
+  import_experimental.experimental
+], CalendarToolset);
+let GmailToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "gmail", apiVersion: "v1" });
+  }
+};
+__name(GmailToolset, "GmailToolset");
+GmailToolset = __decorateClass([
+  import_experimental.experimental
+], GmailToolset);
+let YoutubeToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "youtube", apiVersion: "v3" });
+  }
+};
+__name(YoutubeToolset, "YoutubeToolset");
+YoutubeToolset = __decorateClass([
+  import_experimental.experimental
+], YoutubeToolset);
+let SlidesToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "slides", apiVersion: "v1" });
+  }
+};
+__name(SlidesToolset, "SlidesToolset");
+SlidesToolset = __decorateClass([
+  import_experimental.experimental
+], SlidesToolset);
+let SheetsToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "sheets", apiVersion: "v4" });
+  }
+};
+__name(SheetsToolset, "SheetsToolset");
+SheetsToolset = __decorateClass([
+  import_experimental.experimental
+], SheetsToolset);
+let DocsToolset = class extends import_google_api_toolset.GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "docs", apiVersion: "v1" });
+  }
+};
+__name(DocsToolset, "DocsToolset");
+DocsToolset = __decorateClass([
+  import_experimental.experimental
+], DocsToolset);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BigQueryToolset,
+  CalendarToolset,
+  DocsToolset,
+  GmailToolset,
+  SheetsToolset,
+  SlidesToolset,
+  YoutubeToolset
+});

package/dist/cjs/tools/google_api_tool/googleapi_to_openapi_converter.js

@@ -251,11 +251,13 @@ function convertOperation(methodData, pathParams) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
   const parameters = [];
   for (const paramName of pathParams) {
+    const paramData = methodData.parameters && Object.hasOwn(methodData.parameters, paramName) ? methodData.parameters[paramName] : void 0;
     parameters.push({
       name: paramName,
       in: "path",
+      ...(paramData == null ? void 0 : paramData.description) !== void 0 ? { description: paramData.description } : {},
       required: true,
-      schema: { type: "string" }
+      schema: paramData ? convertParameterSchema(paramData) : { type: "string" }
     });
   }
   const pathParamSet = new Set(pathParams);
@@ -319,10 +321,10 @@ function convertOperation(methodData, pathParams) {
 }
 __name(convertOperation, "convertOperation");
 function convertMethods(methods, _resourcePath, openapiSpec) {
-  var _a, _b;
+  var _a, _b, _c;
   for (const methodData of Object.values(methods)) {
     const httpMethod = ((_a = methodData.httpMethod) != null ? _a : "GET").toLowerCase();
-    let restPath = ((_b = methodData.path) != null ? _b : "/").replace(
+    let restPath = ((_c = (_b = methodData.flatPath) != null ? _b : methodData.path) != null ? _c : "/").replace(
       /\{\+([^{}]+)\}/g,
       (_match, paramName) => `{${paramName}}`
     );

package/dist/cjs/tools/google_api_tool/index.js

@@ -24,24 +24,22 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var google_api_tool_exports = {};
 __export(google_api_tool_exports, {
-  GoogleApiToOpenApiConverter: () => import_googleapi_to_openapi_converter.GoogleApiToOpenApiConverter,
+  BigQueryToolset: () => import_google_api_toolsets.BigQueryToolset,
+  CalendarToolset: () => import_google_api_toolsets.CalendarToolset,
+  DocsToolset: () => import_google_api_toolsets.DocsToolset,
+  GmailToolset: () => import_google_api_toolsets.GmailToolset,
   GoogleApiTool: () => import_google_api_tool.GoogleApiTool,
-  GoogleApiToolSet: () => import_google_api_tool_set.GoogleApiToolSet,
-  bigqueryToolSet: () => import_google_api_tool_sets.bigqueryToolSet,
-  calendarToolSet: () => import_google_api_tool_sets.calendarToolSet,
-  docsToolSet: () => import_google_api_tool_sets.docsToolSet,
-  gmailToolSet: () => import_google_api_tool_sets.gmailToolSet,
+  GoogleApiToolset: () => import_google_api_toolset.GoogleApiToolset,
+  SheetsToolset: () => import_google_api_toolsets.SheetsToolset,
+  SlidesToolset: () => import_google_api_toolsets.SlidesToolset,
+  YoutubeToolset: () => import_google_api_toolsets.YoutubeToolset,
   isGoogleApiTool: () => import_google_api_tool.isGoogleApiTool,
-  isGoogleApiToolSet: () => import_google_api_tool_set.isGoogleApiToolSet,
-  sheetsToolSet: () => import_google_api_tool_sets.sheetsToolSet,
-  slidesToolSet: () => import_google_api_tool_sets.slidesToolSet,
-  youtubeToolSet: () => import_google_api_tool_sets.youtubeToolSet
+  isGoogleApiToolset: () => import_google_api_toolset.isGoogleApiToolset
 });
 module.exports = __toCommonJS(google_api_tool_exports);
 var import_google_api_tool = require("./google_api_tool.js");
-var import_google_api_tool_set = require("./google_api_tool_set.js");
-var import_google_api_tool_sets = require("./google_api_tool_sets.js");
-var import_googleapi_to_openapi_converter = require("./googleapi_to_openapi_converter.js");
+var import_google_api_toolset = require("./google_api_toolset.js");
+var import_google_api_toolsets = require("./google_api_toolsets.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -49,16 +47,15 @@ var import_googleapi_to_openapi_converter = require("./googleapi_to_openapi_conv
  */
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  GoogleApiToOpenApiConverter,
+  BigQueryToolset,
+  CalendarToolset,
+  DocsToolset,
+  GmailToolset,
   GoogleApiTool,
-  GoogleApiToolSet,
-  bigqueryToolSet,
-  calendarToolSet,
-  docsToolSet,
-  gmailToolSet,
+  GoogleApiToolset,
+  SheetsToolset,
+  SlidesToolset,
+  YoutubeToolset,
   isGoogleApiTool,
-  isGoogleApiToolSet,
-  sheetsToolSet,
-  slidesToolSet,
-  youtubeToolSet
+  isGoogleApiToolset
 });

package/dist/cjs/tools/load_artifacts_tool.js

@@ -26,11 +26,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var load_artifacts_tool_exports = {};
 __export(load_artifacts_tool_exports, {
   LOAD_ARTIFACTS: () => LOAD_ARTIFACTS,
-  LoadArtifactsTool: () => LoadArtifactsTool
+  LoadArtifactsTool: () => LoadArtifactsTool,
+  asSafePartForLlm: () => asSafePartForLlm
 });
 module.exports = __toCommonJS(load_artifacts_tool_exports);
 var import_genai = require("@google/genai");
 var import_llm_request = require("../models/llm_request.js");
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
 var import_logger = require("../utils/logger.js");
 var import_base_tool = require("./base_tool.js");
 /**
@@ -49,7 +51,7 @@ function normalizeMimeType(mimeType) {
   if (!mimeType) {
     return void 0;
   }
-  return mimeType.split(";")[0].trim();
+  return mimeType.split(";")[0].trim().toLowerCase();
 }
 __name(normalizeMimeType, "normalizeMimeType");
 function isInlineMimeTypeSupported(mimeType) {
@@ -62,31 +64,44 @@ function isInlineMimeTypeSupported(mimeType) {
   ) || GEMINI_SUPPORTED_INLINE_MIME_TYPES.has(normalized);
 }
 __name(isInlineMimeTypeSupported, "isInlineMimeTypeSupported");
-function asSafePartForLlm(artifact, artifactName) {
+function base64ByteLength(data) {
+  const digits = data.replace(/[=\s]/g, "").length;
+  return Math.floor(digits * 3 / 4);
+}
+__name(base64ByteLength, "base64ByteLength");
+function asSafePartForLlm(artifact, artifactName, options) {
+  if ((options == null ? void 0 : options.inlineMediaAsPlaceholder) && !artifact.inlineData && artifact.fileData) {
+    const fileUri = artifact.fileData.fileUri || "unknown";
+    const mimeType2 = normalizeMimeType(artifact.fileData.mimeType) || "application/octet-stream";
+    return {
+      text: `[Artifact: ${artifactName}, uri: ${fileUri}, type: ${mimeType2}.]`
+    };
+  }
   const inlineData = artifact.inlineData;
   if (!inlineData) {
     return artifact;
   }
-  if (isInlineMimeTypeSupported(inlineData.mimeType)) {
+  if (!(options == null ? void 0 : options.inlineMediaAsPlaceholder) && isInlineMimeTypeSupported(inlineData.mimeType)) {
     return artifact;
   }
   const mimeType = normalizeMimeType(inlineData.mimeType) || "application/octet-stream";
+  const isTextLike = mimeType.startsWith("text/") || TEXT_LIKE_MIME_TYPES.has(mimeType);
   const data = inlineData.data;
-  if (!data) {
+  if (data === void 0 || data === null || !isTextLike && data === "") {
     return {
       text: `[Artifact: ${artifactName}, type: ${mimeType}. No inline data was provided.]`
     };
   }
-  const isTextLike = mimeType.startsWith("text/") || TEXT_LIKE_MIME_TYPES.has(mimeType);
-  const decodedBuffer = Buffer.from(data, "base64");
   if (isTextLike) {
+    if (data === "") {
+      return { text: "" };
+    }
     try {
-      const decoded = decodedBuffer.toString("utf8");
-      return { text: decoded };
+      return { text: (0, import_env_aware_utils.base64Decode)(data.replace(/-/g, "+").replace(/_/g, "/")) };
     } catch {
     }
   }
-  const sizeKb = decodedBuffer.length / 1024;
+  const sizeKb = base64ByteLength(data) / 1024;
   return {
     text: `[Binary artifact: ${artifactName}, type: ${mimeType}, size: ${sizeKb.toFixed(1)} KB. Content cannot be displayed inline.]`
   };
@@ -214,5 +229,6 @@ const LOAD_ARTIFACTS = new LoadArtifactsTool();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LOAD_ARTIFACTS,
-  LoadArtifactsTool
+  LoadArtifactsTool,
+  asSafePartForLlm
 });

package/dist/cjs/tools/load_memory_tool.js

@@ -38,11 +38,13 @@ var import_base_tool = require("./base_tool.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 const _LoadMemoryTool = class _LoadMemoryTool extends import_base_tool.BaseTool {
-  constructor() {
+  constructor(options = {}) {
+    var _a;
     super({
       name: "load_memory",
-      description: "Loads the memory for the current user.\n\nNOTE: Currently this tool only uses text part from the memory."
+      description: "Loads the memory for the current user."
     });
+    this.textOnlyContent = (_a = options.textOnlyContent) != null ? _a : false;
   }
   _getDeclaration() {
     return {
@@ -60,16 +62,13 @@ const _LoadMemoryTool = class _LoadMemoryTool extends import_base_tool.BaseTool
       }
     };
   }
-  async runAsync({
-    args,
-    toolContext
-  }) {
-    try {
-      const query = args["query"];
-      if (!toolContext.invocationContext.memoryService) {
-        throw new Error("Memory service is not initialized.");
-      }
-      const searchMemoryResponse = await toolContext.searchMemory(query);
+  async runAsync({ args, toolContext }) {
+    const query = args["query"];
+    if (!toolContext.invocationContext.memoryService) {
+      throw new Error("Memory service is not initialized.");
+    }
+    const searchMemoryResponse = await toolContext.searchMemory(query);
+    if (this.textOnlyContent) {
       return {
         memories: searchMemoryResponse.memories.map((m) => {
           var _a, _b;
@@ -84,10 +83,10 @@ const _LoadMemoryTool = class _LoadMemoryTool extends import_base_tool.BaseTool
           };
         })
       };
-    } catch (e) {
-      console.error("ERROR in LoadMemoryTool runAsync:", e);
-      throw e;
     }
+    return {
+      memories: searchMemoryResponse.memories
+    };
   }
   async processLlmRequest(request) {
     await super.processLlmRequest(request);

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

@@ -38,6 +38,7 @@ __export(mcp_session_manager_exports, {
   MCPSessionManager: () => MCPSessionManager
 });
 module.exports = __toCommonJS(mcp_session_manager_exports);
+var import_instrumentation = require("../../telemetry/api/instrumentation.js");
 var import_client_labels = require("../../utils/client_labels.js");
 var import_error_utils = require("../../utils/error_utils.js");
 var import_logger = require("../../utils/logger.js");
@@ -63,7 +64,8 @@ function buildTransportOptions(params) {
     requestInit: {
       ...transportOptions == null ? void 0 : transportOptions.requestInit,
       headers: (0, import_client_labels.mergeTrackingHeaders)(callerHeaders)
-    }
+    },
+    fetch: (0, import_instrumentation.instrumentMcpFetch)(transportOptions == null ? void 0 : transportOptions.fetch)
   };
 }
 __name(buildTransportOptions, "buildTransportOptions");
@@ -75,7 +77,8 @@ function buildSseTransportOptions(params) {
     requestInit: {
       ...transportOptions == null ? void 0 : transportOptions.requestInit,
       headers: (0, import_client_labels.mergeTrackingHeaders)(callerHeaders)
-    }
+    },
+    fetch: (0, import_instrumentation.instrumentMcpFetch)(transportOptions == null ? void 0 : transportOptions.fetch)
   };
 }
 __name(buildSseTransportOptions, "buildSseTransportOptions");
@@ -84,6 +87,23 @@ const _MCPSessionManager = class _MCPSessionManager {
     this.activeSessions = /* @__PURE__ */ new Set();
     this.connectionParams = connectionParams;
   }
+  /**
+   * Builds per-request options for MCP client operations.
+   *
+   * For a stdio connection with a configured `timeout`, the timeout is
+   * converted from seconds to milliseconds. Otherwise the MCP SDK applies its
+   * own default request timeout.
+   *
+   * @param signal Optional abort signal to attach to the request.
+   * @return The request options for the MCP SDK client.
+   */
+  getRequestOptions(signal) {
+    const options = signal !== void 0 ? { signal } : {};
+    if (this.connectionParams.type === "StdioConnectionParams" && this.connectionParams.timeout !== void 0) {
+      options.timeout = this.connectionParams.timeout * 1e3;
+    }
+    return options;
+  }
   async createSession() {
     const { Client } = await (0, import_optional_peer.loadOptionalPeer)(
       MCP_SDK,
@@ -101,7 +121,7 @@ const _MCPSessionManager = class _MCPSessionManager {
             this.connectionParams.serverParams
           );
           transport.onerror = logTransportError;
-          await client.connect(transport);
+          await client.connect(transport, this.getRequestOptions());
           break;
         }
         case "StreamableHTTPConnectionParams": {

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

@@ -57,9 +57,13 @@ const _MCPTool = class _MCPTool extends import_base_tool.BaseTool {
     try {
       const callRequest = {};
       callRequest.params = { name: this.originalName, arguments: request.args };
-      const result = await session.callTool(callRequest.params, void 0, {
-        signal: request.toolContext.abortSignal
-      });
+      const result = await session.callTool(
+        callRequest.params,
+        void 0,
+        this.mcpSessionManager.getRequestOptions(
+          request.toolContext.abortSignal
+        )
+      );
       return result;
     } finally {
       await this.mcpSessionManager.closeSession(session);

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

@@ -46,7 +46,10 @@ const _MCPToolset = class _MCPToolset extends import_base_toolset.BaseToolset {
     const session = await this.mcpSessionManager.createSession();
     let listResult;
     try {
-      listResult = await session.listTools();
+      listResult = await session.listTools(
+        void 0,
+        this.mcpSessionManager.getRequestOptions()
+      );
     } finally {
       await this.mcpSessionManager.closeSession(session);
     }
@@ -61,20 +64,7 @@ const _MCPToolset = class _MCPToolset extends import_base_toolset.BaseToolset {
       };
       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;
+    return tools.filter((tool) => this.isToolSelected(tool, context));
   }
   /**
    * Lists the names of the resources advertised by the MCP server.
@@ -84,7 +74,10 @@ const _MCPToolset = class _MCPToolset extends import_base_toolset.BaseToolset {
   async listResources() {
     const session = await this.mcpSessionManager.createSession();
     try {
-      const result = await session.listResources();
+      const result = await session.listResources(
+        void 0,
+        this.mcpSessionManager.getRequestOptions()
+      );
       return result.resources.map((resource) => resource.name);
     } finally {
       await this.mcpSessionManager.closeSession(session);
@@ -101,7 +94,10 @@ const _MCPToolset = class _MCPToolset extends import_base_toolset.BaseToolset {
     const session = await this.mcpSessionManager.createSession();
     let result;
     try {
-      result = await session.listResources();
+      result = await session.listResources(
+        void 0,
+        this.mcpSessionManager.getRequestOptions()
+      );
     } finally {
       await this.mcpSessionManager.closeSession(session);
     }
@@ -131,9 +127,12 @@ const _MCPToolset = class _MCPToolset extends import_base_toolset.BaseToolset {
     }
     const session = await this.mcpSessionManager.createSession();
     try {
-      const result = await session.readResource({
-        uri: resourceInfo.uri
-      });
+      const result = await session.readResource(
+        {
+          uri: resourceInfo.uri
+        },
+        this.mcpSessionManager.getRequestOptions()
+      );
       return result.contents;
     } finally {
       await this.mcpSessionManager.closeSession(session);