mcp-use 1.10.6 → 1.11.0-canary.4

package/dist/{chunk-34R6SIER.js → chunk-FRUZDWXH.js}

@@ -166,7 +166,7 @@ var Logger = class {
           timestamp({ format: "HH:mm:ss" }),
           this.getFormatter()
         ),
-        transports: []
+        transports: [new winston.transports.Console()]
       });
     }
     return this.instances[name];

package/dist/{chunk-CPG2WZUL.js → chunk-JRGQRPTN.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-34R6SIER.js";
+} from "./chunk-FRUZDWXH.js";
 import {
   __name
 } from "./chunk-3GQAWCBQ.js";

package/dist/{chunk-JH3ZOGLI.js → chunk-K6YNB2Z3.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-34R6SIER.js";
+} from "./chunk-FRUZDWXH.js";
 import {
   __name,
   __require
@@ -92,7 +92,7 @@ function generateUUID() {
 __name(generateUUID, "generateUUID");
 
 // src/version.ts
-var VERSION = "1.10.6";
+var VERSION = "1.11.0-canary.4";
 function getPackageVersion() {
   return VERSION;
 }

package/dist/{chunk-EEUJZMOP.js → chunk-LHRGDQ5C.js}

@@ -4,7 +4,7 @@ import {
 import {
   Telemetry,
   generateUUID
-} from "./chunk-JH3ZOGLI.js";
+} from "./chunk-K6YNB2Z3.js";
 import {
   __name
 } from "./chunk-3GQAWCBQ.js";

package/dist/{chunk-44DFBJUL.js → chunk-OIXS25J5.js}

@@ -1,14 +1,12 @@
 import {
   BaseConnector
-} from "./chunk-KIWNNI6F.js";
+} from "./chunk-XXCHNDUF.js";
 import {
-  Tel,
-  generateUUID,
-  getPackageVersion
-} from "./chunk-JH3ZOGLI.js";
+  Tel
+} from "./chunk-K6YNB2Z3.js";
 import {
   logger
-} from "./chunk-34R6SIER.js";
+} from "./chunk-FRUZDWXH.js";
 import {
   __name
 } from "./chunk-3GQAWCBQ.js";
@@ -98,6 +96,22 @@ var MCPSession = class {
   get tools() {
     return this.connector.tools;
   }
+  /**
+   * List all available tools from the MCP server.
+   * This method fetches fresh tools from the server, unlike the `tools` getter which returns cached tools.
+   *
+   * @param options - Optional request options
+   * @returns Array of available tools
+   *
+   * @example
+   * ```typescript
+   * const tools = await session.listTools();
+   * console.log(`Available tools: ${tools.map(t => t.name).join(", ")}`);
+   * ```
+   */
+  async listTools(options) {
+    return this.connector.listTools(options);
+  }
   /**
    * Get the server capabilities advertised during initialization.
    *
@@ -713,279 +727,6 @@ var HttpConnector = class extends BaseConnector {
   }
 };
 
-// src/task_managers/websocket.ts
-import WS from "ws";
-var WebSocketConnectionManager = class extends ConnectionManager {
-  static {
-    __name(this, "WebSocketConnectionManager");
-  }
-  url;
-  headers;
-  _ws = null;
-  /**
-   * @param url     The WebSocket URL to connect to.
-   * @param headers Optional headers to include in the connection handshake.
-   */
-  constructor(url, headers = {}) {
-    super();
-    this.url = url;
-    this.headers = headers;
-  }
-  /** Establish a WebSocket connection and wait until it is open. */
-  async establishConnection() {
-    logger.debug(`Connecting to WebSocket: ${this.url}`);
-    return new Promise((resolve, reject) => {
-      const ws = new WS(this.url, {
-        headers: this.headers
-      });
-      this._ws = ws;
-      const onOpen = /* @__PURE__ */ __name(() => {
-        cleanup();
-        logger.debug("WebSocket connected successfully");
-        resolve(ws);
-      }, "onOpen");
-      const onError = /* @__PURE__ */ __name((err) => {
-        cleanup();
-        logger.error(`Failed to connect to WebSocket: ${err}`);
-        reject(err);
-      }, "onError");
-      const cleanup = /* @__PURE__ */ __name(() => {
-        ws.off("open", onOpen);
-        ws.off("error", onError);
-      }, "cleanup");
-      ws.on("open", onOpen);
-      ws.on("error", onError);
-    });
-  }
-  /** Cleanly close the WebSocket connection. */
-  async closeConnection(connection) {
-    logger.debug("Closing WebSocket connection");
-    return new Promise((resolve) => {
-      const onClose = /* @__PURE__ */ __name(() => {
-        connection.off("close", onClose);
-        this._ws = null;
-        resolve();
-      }, "onClose");
-      if (connection.readyState === WS.CLOSED) {
-        onClose();
-        return;
-      }
-      connection.on("close", onClose);
-      try {
-        connection.close();
-      } catch (e) {
-        logger.warn(`Error closing WebSocket connection: ${e}`);
-        onClose();
-      }
-    });
-  }
-};
-
-// src/connectors/websocket.ts
-var WebSocketConnector = class extends BaseConnector {
-  static {
-    __name(this, "WebSocketConnector");
-  }
-  url;
-  headers;
-  connectionManager = null;
-  ws = null;
-  receiverTask = null;
-  pending = /* @__PURE__ */ new Map();
-  toolsCache = null;
-  constructor(url, opts = {}) {
-    super();
-    this.url = url;
-    this.headers = { ...opts.headers ?? {} };
-    if (opts.authToken) this.headers.Authorization = `Bearer ${opts.authToken}`;
-  }
-  async connect() {
-    if (this.connected) {
-      logger.debug("Already connected to MCP implementation");
-      return;
-    }
-    logger.debug(`Connecting via WebSocket: ${this.url}`);
-    try {
-      this.connectionManager = new WebSocketConnectionManager(
-        this.url,
-        this.headers
-      );
-      this.ws = await this.connectionManager.start();
-      this.receiverTask = this.receiveLoop();
-      this.connected = true;
-      logger.debug("WebSocket connected successfully");
-    } catch (e) {
-      logger.error(`Failed to connect: ${e}`);
-      await this.cleanupResources();
-      throw e;
-    }
-  }
-  async disconnect() {
-    if (!this.connected) {
-      logger.debug("Not connected to MCP implementation");
-      return;
-    }
-    logger.debug("Disconnecting \u2026");
-    await this.cleanupResources();
-    this.connected = false;
-  }
-  sendRequest(method, params = null) {
-    if (!this.ws) throw new Error("WebSocket is not connected");
-    const id = generateUUID();
-    const payload = JSON.stringify({ id, method, params: params ?? {} });
-    return new Promise((resolve, reject) => {
-      this.pending.set(id, { resolve, reject });
-      this.ws.send(payload, (err) => {
-        if (err) {
-          this.pending.delete(id);
-          reject(err);
-        }
-      });
-    });
-  }
-  async receiveLoop() {
-    if (!this.ws) return;
-    const socket = this.ws;
-    const onMessage = /* @__PURE__ */ __name((msg) => {
-      let data;
-      try {
-        data = JSON.parse(msg.data ?? msg);
-      } catch (e) {
-        logger.warn("Received non\u2011JSON frame", e);
-        return;
-      }
-      const id = data.id;
-      if (id && this.pending.has(id)) {
-        const { resolve, reject } = this.pending.get(id);
-        this.pending.delete(id);
-        if ("result" in data) resolve(data.result);
-        else if ("error" in data) reject(data.error);
-      } else if (data.method && !data.id) {
-        logger.debug("Received notification", data.method, data.params);
-        this.handleNotification(data);
-      } else {
-        logger.debug("Received unsolicited message", data);
-      }
-    }, "onMessage");
-    if (socket.addEventListener) {
-      socket.addEventListener("message", onMessage);
-    } else {
-      socket.on("message", onMessage);
-    }
-    return new Promise((resolve) => {
-      const onClose = /* @__PURE__ */ __name(() => {
-        if (socket.removeEventListener) {
-          socket.removeEventListener("message", onMessage);
-        } else {
-          socket.off("message", onMessage);
-        }
-        this.rejectAll(new Error("WebSocket closed"));
-        resolve();
-      }, "onClose");
-      if (socket.addEventListener) {
-        socket.addEventListener("close", onClose);
-      } else {
-        socket.on("close", onClose);
-      }
-    });
-  }
-  rejectAll(err) {
-    for (const { reject } of this.pending.values()) reject(err);
-    this.pending.clear();
-  }
-  async handleNotification(data) {
-    switch (data.method) {
-      case "notifications/tools/list_changed":
-        await this.refreshToolsCache();
-        break;
-      case "notifications/resources/list_changed":
-        await this.onResourcesListChanged();
-        break;
-      case "notifications/prompts/list_changed":
-        await this.onPromptsListChanged();
-        break;
-      default:
-        break;
-    }
-    for (const handler of this.notificationHandlers) {
-      try {
-        await handler({
-          method: data.method,
-          params: data.params
-        });
-      } catch (err) {
-        logger.error("Error in notification handler:", err);
-      }
-    }
-  }
-  /**
-   * Auto-refresh tools cache when server sends tools/list_changed notification
-   * Override to use WebSocket-specific listTools method
-   */
-  async refreshToolsCache() {
-    try {
-      logger.debug(
-        "[Auto] Refreshing tools cache due to list_changed notification"
-      );
-      const tools = await this.listTools();
-      this.toolsCache = tools.map((t) => t);
-      logger.debug(
-        `[Auto] Refreshed tools cache: ${this.toolsCache.length} tools`
-      );
-    } catch (err) {
-      logger.warn("[Auto] Failed to refresh tools cache:", err);
-    }
-  }
-  async initialize() {
-    logger.debug("Initializing MCP session over WebSocket");
-    const result = await this.sendRequest("initialize");
-    const toolsList = await this.listTools();
-    this.toolsCache = toolsList.map((t) => t);
-    logger.debug(`Initialized with ${this.toolsCache.length} tools`);
-    return result;
-  }
-  async listTools() {
-    const res = await this.sendRequest("tools/list");
-    return res.tools ?? [];
-  }
-  async callTool(name, args) {
-    return await this.sendRequest("tools/call", { name, arguments: args });
-  }
-  async listResources() {
-    const resources = await this.sendRequest("resources/list");
-    return { resources: Array.isArray(resources) ? resources : [] };
-  }
-  async readResource(uri) {
-    const res = await this.sendRequest("resources/read", { uri });
-    return res;
-  }
-  async request(method, params = null) {
-    return await this.sendRequest(method, params);
-  }
-  get tools() {
-    if (!this.toolsCache) throw new Error("MCP client is not initialized");
-    return this.toolsCache;
-  }
-  async cleanupResources() {
-    if (this.receiverTask) await this.receiverTask.catch(() => {
-    });
-    this.receiverTask = null;
-    this.rejectAll(new Error("WebSocket disconnected"));
-    if (this.connectionManager) {
-      await this.connectionManager.stop();
-      this.connectionManager = null;
-      this.ws = null;
-    }
-    this.toolsCache = null;
-  }
-  get publicIdentifier() {
-    return {
-      type: "websocket",
-      url: this.url
-    };
-  }
-};
-
 // src/client/base.ts
 var BaseMCPClient = class {
   static {
@@ -1105,101 +846,9 @@ var BaseMCPClient = class {
   }
 };
 
-// src/client/browser.ts
-var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
-  static {
-    __name(this, "BrowserMCPClient");
-  }
-  /**
-   * Get the mcp-use package version.
-   * Works in all environments (Node.js, browser, Cloudflare Workers, Deno, etc.)
-   */
-  static getPackageVersion() {
-    return getPackageVersion();
-  }
-  constructor(config) {
-    super(config);
-    this._trackClientInit();
-  }
-  _trackClientInit() {
-    const servers = Object.keys(this.config.mcpServers ?? {});
-    Tel.getInstance().trackMCPClientInit({
-      codeMode: false,
-      // Browser client doesn't support code mode
-      sandbox: false,
-      // Sandbox not supported in browser
-      allCallbacks: false,
-      // Will be set per-server
-      verify: false,
-      servers,
-      numServers: servers.length,
-      isBrowser: true
-      // Browser MCPClient
-    }).catch(
-      (e) => logger.debug(`Failed to track BrowserMCPClient init: ${e}`)
-    );
-  }
-  static fromDict(cfg) {
-    return new _BrowserMCPClient(cfg);
-  }
-  /**
-   * Create a connector from server configuration (Browser version)
-   * Supports HTTP and WebSocket connectors only
-   */
-  createConnectorFromConfig(serverConfig) {
-    const {
-      url,
-      transport,
-      headers,
-      authToken,
-      authProvider,
-      wrapTransport,
-      clientOptions,
-      samplingCallback,
-      elicitationCallback
-    } = serverConfig;
-    if (!url) {
-      throw new Error("Server URL is required");
-    }
-    const connectorOptions = {
-      headers,
-      authToken,
-      authProvider,
-      // ← Pass OAuth provider to connector
-      wrapTransport,
-      // ← Pass transport wrapper if provided
-      clientOptions,
-      // ← Pass client options (capabilities, etc.) to connector
-      samplingCallback,
-      // ← Pass sampling callback to connector
-      elicitationCallback
-      // ← Pass elicitation callback to connector
-    };
-    if (clientOptions) {
-      console.log(
-        "[BrowserMCPClient] Passing clientOptions to connector:",
-        JSON.stringify(clientOptions, null, 2)
-      );
-    } else {
-      console.warn(
-        "[BrowserMCPClient] No clientOptions provided to connector!"
-      );
-    }
-    if (transport === "websocket" || url.startsWith("ws://") || url.startsWith("wss://")) {
-      return new WebSocketConnector(url, connectorOptions);
-    } else if (transport === "http" || url.startsWith("http://") || url.startsWith("https://")) {
-      return new HttpConnector(url, connectorOptions);
-    } else {
-      return new HttpConnector(url, connectorOptions);
-    }
-  }
-};
-
 export {
   MCPSession,
   BaseMCPClient,
   ConnectionManager,
-  HttpConnector,
-  WebSocketConnector,
-  BrowserMCPClient
+  HttpConnector
 };

package/dist/chunk-QH52FRP3.js

@@ -0,0 +1,101 @@
+import {
+  BaseMCPClient,
+  HttpConnector
+} from "./chunk-OIXS25J5.js";
+import {
+  Tel,
+  getPackageVersion
+} from "./chunk-K6YNB2Z3.js";
+import {
+  logger
+} from "./chunk-FRUZDWXH.js";
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
+
+// src/client/browser.ts
+var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
+  static {
+    __name(this, "BrowserMCPClient");
+  }
+  /**
+   * Get the mcp-use package version.
+   * Works in all environments (Node.js, browser, Cloudflare Workers, Deno, etc.)
+   */
+  static getPackageVersion() {
+    return getPackageVersion();
+  }
+  constructor(config) {
+    super(config);
+    this._trackClientInit();
+  }
+  _trackClientInit() {
+    const servers = Object.keys(this.config.mcpServers ?? {});
+    Tel.getInstance().trackMCPClientInit({
+      codeMode: false,
+      // Browser client doesn't support code mode
+      sandbox: false,
+      // Sandbox not supported in browser
+      allCallbacks: false,
+      // Will be set per-server
+      verify: false,
+      servers,
+      numServers: servers.length,
+      isBrowser: true
+      // Browser MCPClient
+    }).catch(
+      (e) => logger.debug(`Failed to track BrowserMCPClient init: ${e}`)
+    );
+  }
+  static fromDict(cfg) {
+    return new _BrowserMCPClient(cfg);
+  }
+  /**
+   * Create a connector from server configuration (Browser version)
+   * Supports HTTP connector only
+   */
+  createConnectorFromConfig(serverConfig) {
+    const {
+      url,
+      headers,
+      authToken,
+      authProvider,
+      wrapTransport,
+      clientOptions,
+      samplingCallback,
+      elicitationCallback
+    } = serverConfig;
+    if (!url) {
+      throw new Error("Server URL is required");
+    }
+    const connectorOptions = {
+      headers,
+      authToken,
+      authProvider,
+      // ← Pass OAuth provider to connector
+      wrapTransport,
+      // ← Pass transport wrapper if provided
+      clientOptions,
+      // ← Pass client options (capabilities, etc.) to connector
+      samplingCallback,
+      // ← Pass sampling callback to connector
+      elicitationCallback
+      // ← Pass elicitation callback to connector
+    };
+    if (clientOptions) {
+      console.log(
+        "[BrowserMCPClient] Passing clientOptions to connector:",
+        JSON.stringify(clientOptions, null, 2)
+      );
+    } else {
+      console.warn(
+        "[BrowserMCPClient] No clientOptions provided to connector!"
+      );
+    }
+    return new HttpConnector(url, connectorOptions);
+  }
+};
+
+export {
+  BrowserMCPClient
+};

package/dist/chunk-TCLI6SPF.js

@@ -0,0 +1,12 @@
+import {
+  CODE_MODE_AGENT_PROMPT
+} from "./chunk-APOF62EA.js";
+
+// src/client/prompts.ts
+var PROMPTS = {
+  CODE_MODE: CODE_MODE_AGENT_PROMPT
+};
+
+export {
+  PROMPTS
+};

package/dist/{chunk-KIWNNI6F.js → chunk-XXCHNDUF.js}

@@ -1,9 +1,9 @@
 import {
   Telemetry
-} from "./chunk-JH3ZOGLI.js";
+} from "./chunk-K6YNB2Z3.js";
 import {
   logger
-} from "./chunk-34R6SIER.js";
+} from "./chunk-FRUZDWXH.js";
 import {
   __name
 } from "./chunk-3GQAWCBQ.js";
@@ -302,6 +302,20 @@ var BaseConnector = class {
     logger.debug(`Tool '${name}' returned`, res);
     return res;
   }
+  /**
+   * List all available tools from the MCP server.
+   * This method fetches fresh tools from the server, unlike the `tools` getter which returns cached tools.
+   *
+   * @param options - Optional request options
+   * @returns Array of available tools
+   */
+  async listTools(options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    const result = await this.client.listTools(void 0, options);
+    return result.tools ?? [];
+  }
   /**
    * List resources from the server with optional pagination
    *