@google/adk 2.4.0 → 2.5.0

package/dist/esm/tools/computer_use/computer_use_toolset.js

@@ -0,0 +1,344 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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
+ */
+var _a, _b;
+import { Environment } from "@google/genai";
+import { experimental } from "../../utils/experimental.js";
+import { logger } from "../../utils/logger.js";
+import { getGeminiMajorVersion } from "../../utils/model_name.js";
+import { BaseToolset } from "../base_toolset.js";
+import {
+  checkComputerUseEnabled,
+  ComputerEnvironment
+} from "./base_computer.js";
+import {
+  createComputerActions,
+  LEGACY_ACTION_NAMES,
+  OPTIONAL_KEY_ACTIONS,
+  OPTIONAL_MOUSE_ACTIONS,
+  unimplementedOptionalActions
+} from "./computer_use_actions.js";
+import {
+  ComputerUseTool,
+  isComputerUseTool
+} from "./computer_use_tool.js";
+const DIRECT_EXCLUSION_MAP = Object.freeze({
+  // Legacy -> modern.
+  click_at: ["click"],
+  hover_at: ["move"],
+  type_text_at: ["type"],
+  type_text: ["type"],
+  scroll_at: ["scroll"],
+  // Whole-page scroll has no modern counterpart.
+  scroll_document: [],
+  current_state: ["take_screenshot"],
+  key_combination: ["press_key", "hotkey"],
+  wait_5_seconds: ["wait"],
+  // Modern -> legacy.
+  click: ["click_at"],
+  move: ["hover_at"],
+  type: ["type_text_at"],
+  // Does not drop scroll_document.
+  scroll: ["scroll_at"],
+  take_screenshot: ["current_state"],
+  // key_combination is dropped only when both of these are excluded.
+  press_key: [],
+  hotkey: [],
+  wait: ["wait_5_seconds"]
+});
+const LEGACY_EXCLUSION_NAMES = /* @__PURE__ */ new Set([
+  "click_at",
+  "hover_at",
+  "type_text_at",
+  "type_text",
+  "scroll_at",
+  "scroll_document",
+  "current_state",
+  "key_combination",
+  "wait_5_seconds"
+]);
+const MODERN_EXCLUSION_NAMES = /* @__PURE__ */ new Set([
+  "click",
+  "move",
+  "type",
+  "scroll",
+  "take_screenshot",
+  "press_key",
+  "hotkey",
+  "wait",
+  ...OPTIONAL_MOUSE_ACTIONS,
+  ...OPTIONAL_KEY_ACTIONS
+]);
+const TYPING_ACTIONS = ["type", "type_text_at", "type_text"];
+const computerQueues = /* @__PURE__ */ new WeakMap();
+function expandLocalExclusions(excludedNames) {
+  var _a2;
+  const expanded = new Set(excludedNames);
+  for (const name of excludedNames) {
+    for (const counterpart of (_a2 = DIRECT_EXCLUSION_MAP[name]) != null ? _a2 : []) {
+      expanded.add(counterpart);
+    }
+  }
+  if (TYPING_ACTIONS.some((name) => expanded.has(name))) {
+    TYPING_ACTIONS.forEach((name) => expanded.add(name));
+  }
+  if (expanded.has("press_key") && expanded.has("hotkey")) {
+    expanded.add("key_combination");
+  }
+  return expanded;
+}
+__name(expandLocalExclusions, "expandLocalExclusions");
+function resolveExcludedPredefinedFunctions({
+  excludedNames,
+  model,
+  unimplementedActions
+}) {
+  var _a2;
+  const major = getGeminiMajorVersion(model);
+  if (major !== void 0 && major < 3) {
+    if (excludedNames === void 0) {
+      return void 0;
+    }
+    const bothModernKeys = excludedNames.includes("press_key") && excludedNames.includes("hotkey");
+    const resolved2 = [];
+    for (const name of excludedNames) {
+      if (name === "press_key" || name === "hotkey") {
+        if (bothModernKeys) {
+          resolved2.push("key_combination");
+        }
+      } else if (name === "type_text") {
+        resolved2.push("type_text_at");
+      } else if (MODERN_EXCLUSION_NAMES.has(name)) {
+        resolved2.push(...(_a2 = DIRECT_EXCLUSION_MAP[name]) != null ? _a2 : []);
+      } else {
+        resolved2.push(name);
+      }
+    }
+    return [...new Set(resolved2)];
+  }
+  const resolved = [];
+  for (const name of excludedNames != null ? excludedNames : []) {
+    if (LEGACY_EXCLUSION_NAMES.has(name)) {
+      resolved.push(...DIRECT_EXCLUSION_MAP[name]);
+    } else {
+      resolved.push(name);
+    }
+  }
+  if (major !== void 0 && major >= 3) {
+    resolved.push(...unimplementedActions);
+  }
+  const deduped = [...new Set(resolved)];
+  if (deduped.length === 0 && excludedNames === void 0) {
+    return void 0;
+  }
+  return deduped;
+}
+__name(resolveExcludedPredefinedFunctions, "resolveExcludedPredefinedFunctions");
+async function runExclusive(computer, action) {
+  var _a2;
+  const previous = (_a2 = computerQueues.get(computer)) != null ? _a2 : Promise.resolve();
+  const result = previous.then(action);
+  computerQueues.set(
+    computer,
+    result.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return result;
+}
+__name(runExclusive, "runExclusive");
+function toGenaiEnvironment(environment) {
+  switch (environment) {
+    case ComputerEnvironment.ENVIRONMENT_UNSPECIFIED:
+      return Environment.ENVIRONMENT_UNSPECIFIED;
+    case ComputerEnvironment.ENVIRONMENT_BROWSER:
+      return Environment.ENVIRONMENT_BROWSER;
+    default: {
+      const exhaustive = environment;
+      throw new Error(`Unknown computer environment: ${exhaustive}`);
+    }
+  }
+}
+__name(toGenaiEnvironment, "toGenaiEnvironment");
+function isComputerUseConfig(tool) {
+  return "computerUse" in tool && tool.computerUse !== void 0;
+}
+__name(isComputerUseConfig, "isComputerUseConfig");
+async function adaptComputerUseTool({
+  methodName,
+  adapter,
+  llmRequest
+}) {
+  if (!LEGACY_ACTION_NAMES.includes(methodName)) {
+    logger.warn(`Method ${methodName} is not a valid BaseComputer method`);
+    return;
+  }
+  const original = Object.hasOwn(llmRequest.toolsDict, methodName) ? llmRequest.toolsDict[methodName] : void 0;
+  if (!isComputerUseTool(original)) {
+    logger.warn(`Method ${methodName} not found in toolsDict`);
+    return;
+  }
+  const adapted = await adapter(original.func);
+  llmRequest.toolsDict[adapted.name] = new ComputerUseTool({
+    ...adapted,
+    screenSize: original.screenSize,
+    virtualScreenSize: original.virtualScreenSize
+  });
+  if (adapted.name !== methodName) {
+    delete llmRequest.toolsDict[methodName];
+  }
+  logger.debug(`Adapted tool ${methodName} to ${adapted.name}`);
+}
+__name(adaptComputerUseTool, "adaptComputerUseTool");
+const COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.computerUseToolset"
+);
+function isComputerUseToolset(obj) {
+  return typeof obj === "object" && obj !== null && COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL in obj && obj[COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL] === true;
+}
+__name(isComputerUseToolset, "isComputerUseToolset");
+let ComputerUseToolset = class extends (_b = BaseToolset, _a = COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL, _b) {
+  /**
+   * @param options The computer and its configuration.
+   */
+  constructor(options) {
+    var _a2;
+    checkComputerUseEnabled();
+    super([]);
+    /** A unique symbol to identify ADK computer use toolset class. */
+    this[_a] = true;
+    this.closed = false;
+    this.computer = options.computer;
+    this.excludedPredefinedFunctions = options.excludedPredefinedFunctions;
+    this.allowPrivateNetworkAccess = (_a2 = options.allowPrivateNetworkAccess) != null ? _a2 : false;
+  }
+  /**
+   * Returns a tool for every action the computer supports, except the
+   * excluded ones. The computer is initialized on the first call, and the
+   * tools are cached until {@link close}.
+   */
+  async getTools() {
+    var _a2;
+    (_a2 = this.loadingTools) != null ? _a2 : this.loadingTools = this.loadTools();
+    try {
+      return await this.loadingTools;
+    } catch (error) {
+      this.loadingTools = void 0;
+      throw error;
+    }
+  }
+  /**
+   * Closes the computer and drops the cached tools. The next call to
+   * {@link getTools} initializes the computer again.
+   */
+  async close() {
+    if (!this.closed) {
+      await this.computer.close();
+      this.closed = true;
+    }
+    this.initializing = void 0;
+    this.loadingTools = void 0;
+  }
+  /**
+   * Registers the computer use tools in the request and adds the computer use
+   * configuration, unless the request already has one.
+   *
+   * @param _toolContext The context of the tool.
+   * @param llmRequest The outgoing request.
+   */
+  async processLlmRequest(_toolContext, llmRequest) {
+    var _a2, _b2, _c;
+    for (const tool of await this.getTools()) {
+      llmRequest.toolsDict[tool.name] = tool;
+    }
+    (_a2 = llmRequest.config) != null ? _a2 : llmRequest.config = {};
+    (_c = (_b2 = llmRequest.config).tools) != null ? _c : _b2.tools = [];
+    if (llmRequest.config.tools.some(isComputerUseConfig)) {
+      logger.debug("Computer use already configured in LLM request");
+      return;
+    }
+    const environment = toGenaiEnvironment(await this.computer.environment());
+    const excludedPredefinedFunctions = resolveExcludedPredefinedFunctions({
+      excludedNames: this.excludedPredefinedFunctions,
+      model: llmRequest.model,
+      unimplementedActions: unimplementedOptionalActions(this.computer)
+    });
+    llmRequest.config.tools.push({
+      computerUse: excludedPredefinedFunctions === void 0 ? { environment } : { environment, excludedPredefinedFunctions }
+    });
+    logger.debug(
+      `Added computer use tool with environment: ${environment}, excluded functions: ${excludedPredefinedFunctions}`
+    );
+  }
+  ensureInitialized() {
+    var _a2;
+    (_a2 = this.initializing) != null ? _a2 : this.initializing = this.computer.initialize().then(
+      () => {
+        this.closed = false;
+      },
+      (error) => {
+        this.initializing = void 0;
+        throw error;
+      }
+    );
+    return this.initializing;
+  }
+  async loadTools() {
+    var _a2;
+    await this.ensureInitialized();
+    const screenSize = await this.computer.screenSize();
+    const excluded = expandLocalExclusions(
+      (_a2 = this.excludedPredefinedFunctions) != null ? _a2 : []
+    );
+    return createComputerActions({
+      computer: this.computer,
+      allowPrivateNetworkAccess: this.allowPrivateNetworkAccess
+    }).filter((action) => !excluded.has(action.name)).map(
+      (action) => new ComputerUseTool({
+        name: action.name,
+        description: action.description,
+        parameters: action.parameters,
+        execute: this.bindToComputer(action),
+        screenSize
+      })
+    );
+  }
+  /**
+   * Wraps an action so it runs exclusively on the computer, after the
+   * computer has prepared for the calling session.
+   */
+  bindToComputer(action) {
+    const computer = this.computer;
+    return (args, toolContext) => runExclusive(computer, async () => {
+      if (toolContext) {
+        await computer.prepare(toolContext);
+      }
+      return action.execute(args);
+    });
+  }
+};
+__name(ComputerUseToolset, "ComputerUseToolset");
+ComputerUseToolset = __decorateClass([
+  experimental
+], ComputerUseToolset);
+export {
+  ComputerUseToolset,
+  adaptComputerUseTool,
+  isComputerUseToolset
+};

package/dist/esm/tools/function_tool.js

@@ -29,9 +29,10 @@ function toResponseSchema(response) {
     return zodObjectToSchema(response);
   }
   if (typeof response === "object" && response !== null && "safeParse" in response && typeof response.safeParse === "function") {
-    return (_a2 = toGeminiSchema(
-      toJsonSchema(response)
-    )) != null ? _a2 : { type: Type.TYPE_UNSPECIFIED };
+    const jsonSchema = toJsonSchema(response);
+    return (_a2 = toGeminiSchema(jsonSchema)) != null ? _a2 : {
+      type: Type.TYPE_UNSPECIFIED
+    };
   }
   return response;
 }
@@ -251,6 +252,11 @@ function annotateNullableFields(schema) {
     if (!isPlainRecord(propertySchema)) {
       continue;
     }
+    const propType = propertySchema["type"];
+    if (propType === null || propType === "null" || propType === Type.NULL) {
+      propertySchema["type"] = Type.OBJECT;
+      propertySchema["nullable"] = true;
+    }
     const anyOf = propertySchema["anyOf"];
     if (!Array.isArray(anyOf)) {
       continue;
@@ -353,8 +359,12 @@ function processParameterSchema(vertexai, schema) {
 __name(processParameterSchema, "processParameterSchema");
 function mapPropertySchemaType(propertySchema) {
   var _a2, _b2;
-  if (typeof propertySchema["type"] === "string") {
-    propertySchema["type"] = (_a2 = SCHEMA_TYPE_MAP[propertySchema["type"]]) != null ? _a2 : Type.TYPE_UNSPECIFIED;
+  const rawType = propertySchema["type"];
+  if (rawType === null || rawType === "null" || rawType === Type.NULL) {
+    propertySchema["type"] = Type.OBJECT;
+    propertySchema["nullable"] = true;
+  } else if (typeof rawType === "string") {
+    propertySchema["type"] = (_a2 = SCHEMA_TYPE_MAP[rawType]) != null ? _a2 : Type.TYPE_UNSPECIFIED;
     if (propertySchema["type"] === Type.ARRAY && isPlainRecord(propertySchema["items"])) {
       mapPropertySchemaType(propertySchema["items"]);
     }

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

@@ -45,6 +45,7 @@ let GoogleApiToolset = class extends (_b = BaseToolset, _a = GOOGLE_API_TOOLSET_
     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;
@@ -60,7 +61,7 @@ let GoogleApiToolset = class extends (_b = BaseToolset, _a = GOOGLE_API_TOOLSET_
     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 = firstScope ? [firstScope] : void 0;
+    const scopes = this.scopes !== void 0 ? [...this.scopes] : firstScope ? [firstScope] : void 0;
     const authScheme = {
       type: "openIdConnect",
       openIdConnectUrl: "",
@@ -83,7 +84,7 @@ let GoogleApiToolset = class extends (_b = BaseToolset, _a = GOOGLE_API_TOOLSET_
   }
   async ensureToolsLoaded() {
     var _a2;
-    if (this.openapiToolset || !this.apiName || !this.apiVersion) {
+    if (this.openapiToolset) {
       return;
     }
     (_a2 = this.loadingPromise) != null ? _a2 : this.loadingPromise = (async () => {

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

@@ -205,11 +205,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);

package/dist/esm/tools/load_artifacts_tool.js

@@ -25,7 +25,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) {
@@ -43,23 +43,33 @@ function base64ByteLength(data) {
   return Math.floor(digits * 3 / 4);
 }
 __name(base64ByteLength, "base64ByteLength");
-function asSafePartForLlm(artifact, artifactName) {
+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);
   if (isTextLike) {
+    if (data === "") {
+      return { text: "" };
+    }
     try {
       return { text: base64Decode(data.replace(/-/g, "+").replace(/_/g, "/")) };
     } catch {

package/dist/esm/tools/load_memory_tool.js

@@ -17,7 +17,7 @@ const _LoadMemoryTool = class _LoadMemoryTool extends BaseTool {
     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;
   }
@@ -37,10 +37,7 @@ const _LoadMemoryTool = class _LoadMemoryTool extends BaseTool {
       }
     };
   }
-  async runAsync({
-    args,
-    toolContext
-  }) {
+  async runAsync({ args, toolContext }) {
     const query = args["query"];
     if (!toolContext.invocationContext.memoryService) {
       throw new Error("Memory service is not initialized.");

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

@@ -28,6 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { instrumentMcpFetch } from "../../telemetry/api/instrumentation.js";
 import { mergeTrackingHeaders } from "../../utils/client_labels.js";
 import { formatError } from "../../utils/error_utils.js";
 import { logger } from "../../utils/logger.js";
@@ -48,7 +49,8 @@ function buildTransportOptions(params) {
     requestInit: {
       ...transportOptions == null ? void 0 : transportOptions.requestInit,
       headers: mergeTrackingHeaders(callerHeaders)
-    }
+    },
+    fetch: instrumentMcpFetch(transportOptions == null ? void 0 : transportOptions.fetch)
   };
 }
 __name(buildTransportOptions, "buildTransportOptions");
@@ -60,7 +62,8 @@ function buildSseTransportOptions(params) {
     requestInit: {
       ...transportOptions == null ? void 0 : transportOptions.requestInit,
       headers: mergeTrackingHeaders(callerHeaders)
-    }
+    },
+    fetch: instrumentMcpFetch(transportOptions == null ? void 0 : transportOptions.fetch)
   };
 }
 __name(buildSseTransportOptions, "buildSseTransportOptions");
@@ -69,6 +72,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 loadOptionalPeer(
       MCP_SDK,
@@ -86,7 +106,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/esm/tools/mcp/mcp_tool.js

@@ -31,9 +31,13 @@ const _MCPTool = class _MCPTool extends 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/esm/tools/mcp/mcp_toolset.js

@@ -20,7 +20,10 @@ const _MCPToolset = class _MCPToolset extends 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);
     }
@@ -45,7 +48,10 @@ const _MCPToolset = class _MCPToolset extends 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);
@@ -62,7 +68,10 @@ const _MCPToolset = class _MCPToolset extends 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);
     }
@@ -92,9 +101,12 @@ const _MCPToolset = class _MCPToolset extends 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);