mcp-use 1.10.5 → 1.11.0-canary.10

package/dist/{chunk-C7WHRUWQ.js → chunk-BEGEDH6P.js}

@@ -1,14 +1,12 @@
 import {
   BaseConnector
-} from "./chunk-YOHGE3NK.js";
+} from "./chunk-XPTKLSBC.js";
 import {
-  Tel,
-  generateUUID,
-  getPackageVersion
-} from "./chunk-IY632ZQS.js";
+  Tel
+} from "./chunk-3GB7G5X7.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.
    *
@@ -118,7 +132,7 @@ var MCPSession = class {
    * Call a tool on the server.
    *
    * @param name - Name of the tool to call
-   * @param args - Arguments to pass to the tool
+   * @param args - Arguments to pass to the tool (defaults to empty object)
    * @param options - Optional request options (timeout, progress handlers, etc.)
    * @returns Result from the tool execution
    *
@@ -128,7 +142,7 @@ var MCPSession = class {
    * console.log(`Result: ${result.content[0].text}`);
    * ```
    */
-  async callTool(name, args, options) {
+  async callTool(name, args = {}, options) {
     return this.connector.callTool(name, args, options);
   }
   /**
@@ -270,6 +284,134 @@ var MCPSession = class {
   }
 };
 
+// src/client/base.ts
+var BaseMCPClient = class {
+  static {
+    __name(this, "BaseMCPClient");
+  }
+  config = {};
+  sessions = {};
+  activeSessions = [];
+  constructor(config) {
+    if (config) {
+      this.config = config;
+    }
+  }
+  static fromDict(_cfg) {
+    throw new Error("fromDict must be implemented by concrete class");
+  }
+  addServer(name, serverConfig) {
+    this.config.mcpServers = this.config.mcpServers || {};
+    this.config.mcpServers[name] = serverConfig;
+    Tel.getInstance().trackClientAddServer(name, serverConfig);
+  }
+  removeServer(name) {
+    if (this.config.mcpServers?.[name]) {
+      delete this.config.mcpServers[name];
+      this.activeSessions = this.activeSessions.filter((n) => n !== name);
+      Tel.getInstance().trackClientRemoveServer(name);
+    }
+  }
+  getServerNames() {
+    return Object.keys(this.config.mcpServers ?? {});
+  }
+  getServerConfig(name) {
+    return this.config.mcpServers?.[name];
+  }
+  getConfig() {
+    return this.config ?? {};
+  }
+  async createSession(serverName, autoInitialize = true) {
+    const servers = this.config.mcpServers ?? {};
+    if (Object.keys(servers).length === 0) {
+      logger.warn("No MCP servers defined in config");
+    }
+    if (!servers[serverName]) {
+      throw new Error(`Server '${serverName}' not found in config`);
+    }
+    const connector = this.createConnectorFromConfig(servers[serverName]);
+    const session = new MCPSession(connector);
+    if (autoInitialize) {
+      await session.initialize();
+    }
+    this.sessions[serverName] = session;
+    if (!this.activeSessions.includes(serverName)) {
+      this.activeSessions.push(serverName);
+    }
+    return session;
+  }
+  async createAllSessions(autoInitialize = true) {
+    const servers = this.config.mcpServers ?? {};
+    if (Object.keys(servers).length === 0) {
+      logger.warn("No MCP servers defined in config");
+    }
+    for (const name of Object.keys(servers)) {
+      await this.createSession(name, autoInitialize);
+    }
+    return this.sessions;
+  }
+  getSession(serverName) {
+    const session = this.sessions[serverName];
+    if (!session) {
+      return null;
+    }
+    return session;
+  }
+  requireSession(serverName) {
+    const session = this.sessions[serverName];
+    if (!session) {
+      throw new Error(
+        `Session '${serverName}' not found. Available sessions: ${this.activeSessions.join(", ") || "none"}`
+      );
+    }
+    return session;
+  }
+  getAllActiveSessions() {
+    return Object.fromEntries(
+      this.activeSessions.map((n) => [n, this.sessions[n]])
+    );
+  }
+  async closeSession(serverName) {
+    const session = this.sessions[serverName];
+    if (!session) {
+      logger.warn(
+        `No session exists for server ${serverName}, nothing to close`
+      );
+      return;
+    }
+    try {
+      logger.debug(`Closing session for server ${serverName}`);
+      await session.disconnect();
+    } catch (e) {
+      logger.error(`Error closing session for server '${serverName}': ${e}`);
+    } finally {
+      delete this.sessions[serverName];
+      this.activeSessions = this.activeSessions.filter((n) => n !== serverName);
+    }
+  }
+  async closeAllSessions() {
+    const serverNames = Object.keys(this.sessions);
+    const errors = [];
+    for (const serverName of serverNames) {
+      try {
+        logger.debug(`Closing session for server ${serverName}`);
+        await this.closeSession(serverName);
+      } catch (e) {
+        const errorMsg = `Failed to close session for server '${serverName}': ${e}`;
+        logger.error(errorMsg);
+        errors.push(errorMsg);
+      }
+    }
+    if (errors.length) {
+      logger.error(
+        `Encountered ${errors.length} errors while closing sessions`
+      );
+    } else {
+      logger.debug("All sessions closed successfully");
+    }
+  }
+};
+
 // src/connectors/http.ts
 import { Client } from "@mcp-use/modelcontextprotocol-sdk/client/index.js";
 import {
@@ -405,6 +547,7 @@ var SseConnectionManager = class extends ConnectionManager {
   url;
   opts;
   _transport = null;
+  reinitializing = false;
   /**
    * Create an SSE connection manager.
    *
@@ -417,12 +560,53 @@ var SseConnectionManager = class extends ConnectionManager {
     this.opts = opts;
   }
   /**
-   * Spawn a new `SSEClientTransport` and start the connection.
+   * Spawn a new `SSEClientTransport` and wrap it with 404 handling.
+   * Per MCP spec, clients MUST re-initialize when receiving 404 for stale sessions.
    */
   async establishConnection() {
-    this._transport = new SSEClientTransport(this.url, this.opts);
+    const transport = new SSEClientTransport(this.url, this.opts);
+    const originalSend = transport.send.bind(transport);
+    transport.send = async (message) => {
+      const sendMessage = /* @__PURE__ */ __name(async (msg) => {
+        if (Array.isArray(msg)) {
+          for (const singleMsg of msg) {
+            await originalSend(singleMsg);
+          }
+        } else {
+          await originalSend(msg);
+        }
+      }, "sendMessage");
+      try {
+        await sendMessage(message);
+      } catch (error) {
+        if (error?.code === 404 && transport.sessionId && !this.reinitializing) {
+          logger.warn(
+            `[SSE] Session not found (404), re-initializing per MCP spec...`
+          );
+          this.reinitializing = true;
+          try {
+            transport.sessionId = void 0;
+            await this.reinitialize(transport);
+            logger.info(`[SSE] Re-initialization successful, retrying request`);
+            await sendMessage(message);
+          } finally {
+            this.reinitializing = false;
+          }
+        } else {
+          throw error;
+        }
+      }
+    };
+    this._transport = transport;
     logger.debug(`${this.constructor.name} connected successfully`);
-    return this._transport;
+    return transport;
+  }
+  /**
+   * Re-initialize the transport with a new session
+   * This is called when the server returns 404 for a stale session
+   */
+  async reinitialize(transport) {
+    logger.debug(`[SSE] Re-initialization triggered`);
   }
   /**
    * Close the underlying transport and clean up resources.
@@ -713,493 +897,9 @@ 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 {
-    __name(this, "BaseMCPClient");
-  }
-  config = {};
-  sessions = {};
-  activeSessions = [];
-  constructor(config) {
-    if (config) {
-      this.config = config;
-    }
-  }
-  static fromDict(_cfg) {
-    throw new Error("fromDict must be implemented by concrete class");
-  }
-  addServer(name, serverConfig) {
-    this.config.mcpServers = this.config.mcpServers || {};
-    this.config.mcpServers[name] = serverConfig;
-    Tel.getInstance().trackClientAddServer(name, serverConfig);
-  }
-  removeServer(name) {
-    if (this.config.mcpServers?.[name]) {
-      delete this.config.mcpServers[name];
-      this.activeSessions = this.activeSessions.filter((n) => n !== name);
-      Tel.getInstance().trackClientRemoveServer(name);
-    }
-  }
-  getServerNames() {
-    return Object.keys(this.config.mcpServers ?? {});
-  }
-  getServerConfig(name) {
-    return this.config.mcpServers?.[name];
-  }
-  getConfig() {
-    return this.config ?? {};
-  }
-  async createSession(serverName, autoInitialize = true) {
-    const servers = this.config.mcpServers ?? {};
-    if (Object.keys(servers).length === 0) {
-      logger.warn("No MCP servers defined in config");
-    }
-    if (!servers[serverName]) {
-      throw new Error(`Server '${serverName}' not found in config`);
-    }
-    const connector = this.createConnectorFromConfig(servers[serverName]);
-    const session = new MCPSession(connector);
-    if (autoInitialize) {
-      await session.initialize();
-    }
-    this.sessions[serverName] = session;
-    if (!this.activeSessions.includes(serverName)) {
-      this.activeSessions.push(serverName);
-    }
-    return session;
-  }
-  async createAllSessions(autoInitialize = true) {
-    const servers = this.config.mcpServers ?? {};
-    if (Object.keys(servers).length === 0) {
-      logger.warn("No MCP servers defined in config");
-    }
-    for (const name of Object.keys(servers)) {
-      await this.createSession(name, autoInitialize);
-    }
-    return this.sessions;
-  }
-  getSession(serverName) {
-    const session = this.sessions[serverName];
-    if (!session) {
-      return null;
-    }
-    return session;
-  }
-  getAllActiveSessions() {
-    return Object.fromEntries(
-      this.activeSessions.map((n) => [n, this.sessions[n]])
-    );
-  }
-  async closeSession(serverName) {
-    const session = this.sessions[serverName];
-    if (!session) {
-      logger.warn(
-        `No session exists for server ${serverName}, nothing to close`
-      );
-      return;
-    }
-    try {
-      logger.debug(`Closing session for server ${serverName}`);
-      await session.disconnect();
-    } catch (e) {
-      logger.error(`Error closing session for server '${serverName}': ${e}`);
-    } finally {
-      delete this.sessions[serverName];
-      this.activeSessions = this.activeSessions.filter((n) => n !== serverName);
-    }
-  }
-  async closeAllSessions() {
-    const serverNames = Object.keys(this.sessions);
-    const errors = [];
-    for (const serverName of serverNames) {
-      try {
-        logger.debug(`Closing session for server ${serverName}`);
-        await this.closeSession(serverName);
-      } catch (e) {
-        const errorMsg = `Failed to close session for server '${serverName}': ${e}`;
-        logger.error(errorMsg);
-        errors.push(errorMsg);
-      }
-    }
-    if (errors.length) {
-      logger.error(
-        `Encountered ${errors.length} errors while closing sessions`
-      );
-    } else {
-      logger.debug("All sessions closed successfully");
-    }
-  }
-};
-
-// 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
 };