mcp-use 1.5.0 → 1.5.1-canary.0

package/dist/{chunk-WERYJ6PF.js → chunk-2AOGMX4T.js}

@@ -1,6 +1,6 @@
 import {
   BaseConnector
-} from "./chunk-DSBKVAWD.js";
+} from "./chunk-2JBWOW4S.js";
 import {
   __name
 } from "./chunk-3GQAWCBQ.js";

package/dist/{chunk-DSBKVAWD.js → chunk-2JBWOW4S.js}

@@ -6,6 +6,10 @@ import {
 } from "./chunk-3GQAWCBQ.js";
 
 // src/connectors/base.ts
+import {
+  ListRootsRequestSchema,
+  CreateMessageRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
 var BaseConnector = class {
   static {
     __name(this, "BaseConnector");
@@ -17,8 +21,156 @@ var BaseConnector = class {
   serverInfoCache = null;
   connected = false;
   opts;
+  notificationHandlers = [];
+  rootsCache = [];
   constructor(opts = {}) {
     this.opts = opts;
+    if (opts.roots) {
+      this.rootsCache = [...opts.roots];
+    }
+  }
+  /**
+   * Register a handler for server notifications
+   *
+   * @param handler - Function to call when a notification is received
+   *
+   * @example
+   * ```typescript
+   * connector.onNotification((notification) => {
+   *   console.log(`Received: ${notification.method}`, notification.params);
+   * });
+   * ```
+   */
+  onNotification(handler) {
+    this.notificationHandlers.push(handler);
+    if (this.client) {
+      this.setupNotificationHandler();
+    }
+  }
+  /**
+   * Internal: wire notification handlers to the SDK client
+   * Includes automatic handling for list_changed notifications per MCP spec
+   */
+  setupNotificationHandler() {
+    if (!this.client) return;
+    this.client.fallbackNotificationHandler = async (notification) => {
+      switch (notification.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(notification);
+        } catch (err) {
+          logger.error("Error in notification handler:", err);
+        }
+      }
+    };
+  }
+  /**
+   * Auto-refresh tools cache when server sends tools/list_changed notification
+   */
+  async refreshToolsCache() {
+    if (!this.client) return;
+    try {
+      logger.debug(
+        "[Auto] Refreshing tools cache due to list_changed notification"
+      );
+      const result = await this.client.listTools();
+      this.toolsCache = result.tools ?? [];
+      logger.debug(
+        `[Auto] Refreshed tools cache: ${this.toolsCache.length} tools`
+      );
+    } catch (err) {
+      logger.warn("[Auto] Failed to refresh tools cache:", err);
+    }
+  }
+  /**
+   * Called when server sends resources/list_changed notification
+   * Resources aren't cached by default, but we log for user awareness
+   */
+  async onResourcesListChanged() {
+    logger.debug(
+      "[Auto] Resources list changed - clients should re-fetch if needed"
+    );
+  }
+  /**
+   * Called when server sends prompts/list_changed notification
+   * Prompts aren't cached by default, but we log for user awareness
+   */
+  async onPromptsListChanged() {
+    logger.debug(
+      "[Auto] Prompts list changed - clients should re-fetch if needed"
+    );
+  }
+  /**
+   * Set roots and notify the server.
+   * Roots represent directories or files that the client has access to.
+   *
+   * @param roots - Array of Root objects with `uri` (must start with "file://") and optional `name`
+   *
+   * @example
+   * ```typescript
+   * await connector.setRoots([
+   *   { uri: "file:///home/user/project", name: "My Project" },
+   *   { uri: "file:///home/user/data" }
+   * ]);
+   * ```
+   */
+  async setRoots(roots) {
+    this.rootsCache = [...roots];
+    if (this.client) {
+      logger.debug(
+        `Sending roots/list_changed notification with ${roots.length} root(s)`
+      );
+      await this.client.sendRootsListChanged();
+    }
+  }
+  /**
+   * Get the current roots.
+   */
+  getRoots() {
+    return [...this.rootsCache];
+  }
+  /**
+   * Internal: set up roots/list request handler.
+   * This is called after the client connects to register the handler for server requests.
+   */
+  setupRootsHandler() {
+    if (!this.client) return;
+    this.client.setRequestHandler(
+      ListRootsRequestSchema,
+      async (_request, _extra) => {
+        logger.debug(
+          `Server requested roots list, returning ${this.rootsCache.length} root(s)`
+        );
+        return { roots: this.rootsCache };
+      }
+    );
+  }
+  /**
+   * Internal: set up sampling/createMessage request handler.
+   * This is called after the client connects to register the handler for sampling requests.
+   */
+  setupSamplingHandler() {
+    if (!this.client) return;
+    if (!this.opts.samplingCallback) return;
+    this.client.setRequestHandler(
+      CreateMessageRequestSchema,
+      async (request, _extra) => {
+        logger.debug("Server requested sampling, forwarding to callback");
+        return await this.opts.samplingCallback(request.params);
+      }
+    );
   }
   /** Disconnect and release resources. */
   async disconnect() {

package/dist/{chunk-UT7O4SIJ.js → chunk-BWOTID2D.js}

@@ -1,6 +1,6 @@
 import {
   BaseConnector
-} from "./chunk-DSBKVAWD.js";
+} from "./chunk-2JBWOW4S.js";
 import {
   logger
 } from "./chunk-34R6SIER.js";
@@ -34,11 +34,59 @@ var MCPSession = class {
   get isConnected() {
     return this.connector && this.connector.isClientConnected;
   }
+  /**
+   * Register an event handler for session events
+   *
+   * @param event - The event type to listen for
+   * @param handler - The handler function to call when the event occurs
+   *
+   * @example
+   * ```typescript
+   * session.on("notification", async (notification) => {
+   *   console.log(`Received: ${notification.method}`, notification.params);
+   *
+   *   if (notification.method === "notifications/tools/list_changed") {
+   *     // Refresh tools list
+   *   }
+   * });
+   * ```
+   */
+  on(event, handler) {
+    if (event === "notification") {
+      this.connector.onNotification(handler);
+    }
+  }
+  /**
+   * Set roots and notify the server.
+   * Roots represent directories or files that the client has access to.
+   *
+   * @param roots - Array of Root objects with `uri` (must start with "file://") and optional `name`
+   *
+   * @example
+   * ```typescript
+   * await session.setRoots([
+   *   { uri: "file:///home/user/project", name: "My Project" },
+   *   { uri: "file:///home/user/data" }
+   * ]);
+   * ```
+   */
+  async setRoots(roots) {
+    return this.connector.setRoots(roots);
+  }
+  /**
+   * Get the current roots.
+   */
+  getRoots() {
+    return this.connector.getRoots();
+  }
 };
 
 // src/connectors/http.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import {
+  StreamableHTTPClientTransport,
+  StreamableHTTPError
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
 // src/task_managers/sse.ts
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
@@ -203,57 +251,6 @@ var SseConnectionManager = class extends ConnectionManager {
   }
 };
 
-// src/task_managers/streamable_http.ts
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-var StreamableHttpConnectionManager = class extends ConnectionManager {
-  static {
-    __name(this, "StreamableHttpConnectionManager");
-  }
-  url;
-  opts;
-  _transport = null;
-  /**
-   * Create a Streamable HTTP connection manager.
-   *
-   * @param url  The HTTP endpoint URL.
-   * @param opts Optional transport options (auth, headers, etc.).
-   */
-  constructor(url, opts) {
-    super();
-    this.url = typeof url === "string" ? new URL(url) : url;
-    this.opts = opts;
-  }
-  /**
-   * Spawn a new `StreamableHTTPClientTransport` and return it.
-   * The Client.connect() method will handle starting the transport.
-   */
-  async establishConnection() {
-    this._transport = new StreamableHTTPClientTransport(this.url, this.opts);
-    logger.debug(`${this.constructor.name} created successfully`);
-    return this._transport;
-  }
-  /**
-   * Close the underlying transport and clean up resources.
-   */
-  async closeConnection(_connection) {
-    if (this._transport) {
-      try {
-        await this._transport.close();
-      } catch (e) {
-        logger.warn(`Error closing Streamable HTTP transport: ${e}`);
-      } finally {
-        this._transport = null;
-      }
-    }
-  }
-  /**
-   * Get the session ID from the transport if available.
-   */
-  get sessionId() {
-    return this._transport?.sessionId;
-  }
-};
-
 // src/connectors/http.ts
 var HttpConnector = class extends BaseConnector {
   static {
@@ -266,6 +263,7 @@ var HttpConnector = class extends BaseConnector {
   clientInfo;
   preferSse;
   transportType = null;
+  streamableTransport = null;
   constructor(baseUrl, opts = {}) {
     super(opts);
     this.baseUrl = baseUrl.replace(/\/$/, "");
@@ -357,34 +355,67 @@ var HttpConnector = class extends BaseConnector {
   }
   async connectWithStreamableHttp(baseUrl) {
     try {
-      this.connectionManager = new StreamableHttpConnectionManager(baseUrl, {
-        authProvider: this.opts.authProvider,
-        // ← Pass OAuth provider to SDK
-        requestInit: {
-          headers: this.headers
-        },
-        // Pass through timeout and other options
-        reconnectionOptions: {
-          maxReconnectionDelay: 3e4,
-          initialReconnectionDelay: 1e3,
-          reconnectionDelayGrowFactor: 1.5,
-          maxRetries: 2
+      const streamableTransport = new StreamableHTTPClientTransport(
+        new URL(baseUrl),
+        {
+          authProvider: this.opts.authProvider,
+          // ← Pass OAuth provider to SDK
+          requestInit: {
+            headers: this.headers
+          },
+          // Pass through reconnection options
+          reconnectionOptions: {
+            maxReconnectionDelay: 3e4,
+            initialReconnectionDelay: 1e3,
+            reconnectionDelayGrowFactor: 1.5,
+            maxRetries: 2
+          }
+          // Don't pass sessionId - let the SDK generate it automatically during connect()
         }
-      });
-      let transport = await this.connectionManager.start();
+      );
+      let transport = streamableTransport;
       if (this.opts.wrapTransport) {
         const serverId = this.baseUrl;
-        transport = this.opts.wrapTransport(transport, serverId);
+        transport = this.opts.wrapTransport(
+          transport,
+          serverId
+        );
       }
-      this.client = new Client(this.clientInfo, this.opts.clientOptions);
+      const clientOptions = {
+        ...this.opts.clientOptions || {},
+        capabilities: {
+          ...this.opts.clientOptions?.capabilities || {},
+          roots: { listChanged: true },
+          // Always advertise roots capability
+          // Add sampling capability if callback is provided
+          ...this.opts.samplingCallback ? { sampling: {} } : {}
+        }
+      };
+      logger.debug(
+        `Creating Client with capabilities:`,
+        JSON.stringify(clientOptions.capabilities, null, 2)
+      );
+      this.client = new Client(this.clientInfo, clientOptions);
+      this.setupRootsHandler();
+      logger.debug("Roots handler registered before connect");
       try {
-        await this.client.connect(transport);
+        await this.client.connect(transport, {
+          timeout: Math.min(this.timeout, 3e3)
+        });
+        const sessionId = streamableTransport.sessionId;
+        if (sessionId) {
+          logger.debug(`Session ID obtained: ${sessionId}`);
+        } else {
+          logger.warn(
+            "Session ID not available after connect - this may cause issues with SSE stream"
+          );
+        }
       } catch (connectErr) {
         if (connectErr instanceof Error) {
           const errMsg = connectErr.message || connectErr.toString();
-          if (errMsg.includes("Missing session ID") || errMsg.includes("Bad Request: Missing session ID")) {
+          if (errMsg.includes("Missing session ID") || errMsg.includes("Bad Request: Missing session ID") || errMsg.includes("Mcp-Session-Id header is required")) {
             const wrappedError = new Error(
-              `FastMCP session ID error: ${errMsg}`
+              `Session ID error: ${errMsg}. The SDK should automatically extract session ID from initialize response.`
             );
             wrappedError.cause = connectErr;
             throw wrappedError;
@@ -392,8 +423,24 @@ var HttpConnector = class extends BaseConnector {
         }
         throw connectErr;
       }
+      this.streamableTransport = streamableTransport;
+      this.connectionManager = {
+        stop: /* @__PURE__ */ __name(async () => {
+          if (this.streamableTransport) {
+            try {
+              await this.streamableTransport.close();
+            } catch (e) {
+              logger.warn(`Error closing Streamable HTTP transport: ${e}`);
+            } finally {
+              this.streamableTransport = null;
+            }
+          }
+        }, "stop")
+      };
       this.connected = true;
       this.transportType = "streamable-http";
+      this.setupNotificationHandler();
+      this.setupSamplingHandler();
       logger.debug(
         `Successfully connected to MCP implementation via streamable HTTP: ${baseUrl}`
       );
@@ -414,10 +461,28 @@ var HttpConnector = class extends BaseConnector {
         const serverId = this.baseUrl;
         transport = this.opts.wrapTransport(transport, serverId);
       }
-      this.client = new Client(this.clientInfo, this.opts.clientOptions);
+      const clientOptions = {
+        ...this.opts.clientOptions || {},
+        capabilities: {
+          ...this.opts.clientOptions?.capabilities || {},
+          roots: { listChanged: true },
+          // Always advertise roots capability
+          // Add sampling capability if callback is provided
+          ...this.opts.samplingCallback ? { sampling: {} } : {}
+        }
+      };
+      logger.debug(
+        `Creating Client with capabilities (SSE):`,
+        JSON.stringify(clientOptions.capabilities, null, 2)
+      );
+      this.client = new Client(this.clientInfo, clientOptions);
+      this.setupRootsHandler();
+      logger.debug("Roots handler registered before connect (SSE)");
       await this.client.connect(transport);
       this.connected = true;
       this.transportType = "sse";
+      this.setupNotificationHandler();
+      this.setupSamplingHandler();
       logger.debug(
         `Successfully connected to MCP implementation via HTTP/SSE: ${baseUrl}`
       );
@@ -591,6 +656,9 @@ var WebSocketConnector = class extends BaseConnector {
         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);
       }
@@ -621,6 +689,49 @@ var WebSocketConnector = class extends BaseConnector {
     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");
@@ -1148,7 +1259,16 @@ var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
    * Supports HTTP and WebSocket connectors only
    */
   createConnectorFromConfig(serverConfig) {
-    const { url, transport, headers, authToken, authProvider, wrapTransport } = serverConfig;
+    const {
+      url,
+      transport,
+      headers,
+      authToken,
+      authProvider,
+      wrapTransport,
+      clientOptions,
+      samplingCallback
+    } = serverConfig;
     if (!url) {
       throw new Error("Server URL is required");
     }
@@ -1157,9 +1277,23 @@ var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
       authToken,
       authProvider,
       // ← Pass OAuth provider to connector
-      wrapTransport
+      wrapTransport,
       // ← Pass transport wrapper if provided
+      clientOptions,
+      // ← Pass client options (capabilities, etc.) to connector
+      samplingCallback
+      // ← Pass sampling 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://")) {

package/dist/{chunk-GPAOZN2F.js → chunk-QRABML5H.js}

@@ -1,7 +1,7 @@
 import {
   BrowserMCPClient,
   BrowserOAuthClientProvider
-} from "./chunk-UT7O4SIJ.js";
+} from "./chunk-BWOTID2D.js";
 import {
   __name
 } from "./chunk-3GQAWCBQ.js";
@@ -44,7 +44,9 @@ function useMcp(options) {
     // 30 seconds default for connection timeout
     sseReadTimeout = 3e5,
     // 5 minutes default for SSE read timeout
-    wrapTransport
+    wrapTransport,
+    onNotification,
+    samplingCallback
   } = options;
   const [state, setState] = useState("discovering");
   const [tools, setTools] = useState([]);
@@ -197,6 +199,10 @@ function useMcp(options) {
           ...serverConfig,
           authProvider: authProviderRef.current,
           // ← SDK handles OAuth automatically!
+          clientOptions: clientConfig,
+          // ← Pass client config to connector
+          samplingCallback,
+          // ← Pass sampling callback to connector
           wrapTransport: wrapTransport ? (transport) => {
             console.log(
               "[useMcp] Applying transport wrapper for server:",
@@ -207,7 +213,13 @@ function useMcp(options) {
             return wrapTransport(transport, url);
           } : void 0
         });
-        const session = await clientRef.current.createSession(serverName);
+        const session = await clientRef.current.createSession(
+          serverName,
+          false
+        );
+        if (onNotification) {
+          session.on("notification", onNotification);
+        }
         await session.initialize();
         addLog("info", "\u2705 Successfully connected to MCP server");
         addLog("info", "Server info:", session.connector.serverInfo);