mcp-use 1.5.0 → 1.5.1-canary.0

package/dist/index.js

@@ -22,7 +22,7 @@ import {
 import {
   CodeModeConnector,
   PROMPTS
-} from "./chunk-WERYJ6PF.js";
+} from "./chunk-2AOGMX4T.js";
 import {
   ErrorBoundary,
   Image,
@@ -34,7 +34,7 @@ import {
   useWidgetProps,
   useWidgetState,
   useWidgetTheme
-} from "./chunk-GPAOZN2F.js";
+} from "./chunk-QRABML5H.js";
 import {
   BaseMCPClient,
   BrowserOAuthClientProvider,
@@ -43,10 +43,10 @@ import {
   MCPSession,
   WebSocketConnector,
   onMcpAuthorization
-} from "./chunk-UT7O4SIJ.js";
+} from "./chunk-BWOTID2D.js";
 import {
   BaseConnector
-} from "./chunk-DSBKVAWD.js";
+} from "./chunk-2JBWOW4S.js";
 import "./chunk-YURRUCIM.js";
 import {
   Logger,
@@ -808,9 +808,22 @@ var StdioConnector = class extends BaseConnector {
         this.errlog
       );
       const transport = await this.connectionManager.start();
-      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: {} } : {}
+        }
+      };
+      this.client = new Client(this.clientInfo, clientOptions);
       await this.client.connect(transport);
       this.connected = true;
+      this.setupNotificationHandler();
+      this.setupRootsHandler();
+      this.setupSamplingHandler();
       logger.debug(
         `Successfully connected to MCP implementation: ${this.command}`
       );
@@ -834,12 +847,13 @@ function loadConfigFile(filepath) {
   return JSON.parse(raw);
 }
 __name(loadConfigFile, "loadConfigFile");
-function createConnectorFromConfig(serverConfig) {
+function createConnectorFromConfig(serverConfig, connectorOptions) {
   if ("command" in serverConfig && "args" in serverConfig) {
     return new StdioConnector({
       command: serverConfig.command,
       args: serverConfig.args,
-      env: serverConfig.env
+      env: serverConfig.env,
+      ...connectorOptions
     });
   }
   if ("url" in serverConfig) {
@@ -848,13 +862,15 @@ function createConnectorFromConfig(serverConfig) {
       headers: serverConfig.headers,
       authToken: serverConfig.auth_token || serverConfig.authToken,
       // Only force SSE if explicitly requested
-      preferSse: serverConfig.preferSse || transport === "sse"
+      preferSse: serverConfig.preferSse || transport === "sse",
+      ...connectorOptions
     });
   }
   if ("ws_url" in serverConfig) {
     return new WebSocketConnector(serverConfig.ws_url, {
       headers: serverConfig.headers,
-      authToken: serverConfig.auth_token
+      authToken: serverConfig.auth_token,
+      ...connectorOptions
     });
   }
   throw new Error("Cannot determine connector type from config");
@@ -871,6 +887,7 @@ var MCPClient = class _MCPClient extends BaseMCPClient {
   _customCodeExecutor = null;
   _codeExecutorConfig = "vm";
   _executorOptions;
+  _samplingCallback;
   constructor(config, options) {
     if (config) {
       if (typeof config === "string") {
@@ -896,6 +913,7 @@ var MCPClient = class _MCPClient extends BaseMCPClient {
     this.codeMode = codeModeEnabled;
     this._codeExecutorConfig = executorConfig;
     this._executorOptions = executorOptions;
+    this._samplingCallback = options?.samplingCallback;
     if (this.codeMode) {
       this._setupCodeModeConnector();
     }
@@ -921,7 +939,9 @@ var MCPClient = class _MCPClient extends BaseMCPClient {
    * Supports all connector types including StdioConnector
    */
   createConnectorFromConfig(serverConfig) {
-    return createConnectorFromConfig(serverConfig);
+    return createConnectorFromConfig(serverConfig, {
+      samplingCallback: this._samplingCallback
+    });
   }
   _setupCodeModeConnector() {
     logger.debug("Code mode connector initialized as internal meta server");

package/dist/src/agents/index.cjs

@@ -995,6 +995,7 @@ __export(agents_exports, {
 module.exports = __toCommonJS(agents_exports);
 
 // src/connectors/base.ts
+var import_types = require("@modelcontextprotocol/sdk/types.js");
 init_logging();
 
 // src/client/connectors/codeMode.ts

package/dist/src/agents/index.js

@@ -7,8 +7,8 @@ import {
 } from "../../chunk-MCF5P6GJ.js";
 import {
   PROMPTS
-} from "../../chunk-WERYJ6PF.js";
-import "../../chunk-DSBKVAWD.js";
+} from "../../chunk-2AOGMX4T.js";
+import "../../chunk-2JBWOW4S.js";
 import "../../chunk-YURRUCIM.js";
 import "../../chunk-34R6SIER.js";
 import "../../chunk-3GQAWCBQ.js";

package/dist/src/browser.cjs

@@ -1009,7 +1009,7 @@ module.exports = __toCommonJS(browser_exports);
 
 // src/connectors/http.ts
 var import_client = require("@modelcontextprotocol/sdk/client/index.js");
-var import_streamableHttp2 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
 init_logging();
 
 // src/task_managers/sse.ts
@@ -1177,73 +1177,170 @@ var SseConnectionManager = class extends ConnectionManager {
   }
 };
 
-// src/task_managers/streamable_http.ts
-var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+// src/connectors/base.ts
+var import_types = require("@modelcontextprotocol/sdk/types.js");
 init_logging();
-var StreamableHttpConnectionManager = class extends ConnectionManager {
+var BaseConnector = class {
   static {
-    __name(this, "StreamableHttpConnectionManager");
+    __name(this, "BaseConnector");
   }
-  url;
+  client = null;
+  connectionManager = null;
+  toolsCache = null;
+  capabilitiesCache = null;
+  serverInfoCache = null;
+  connected = false;
   opts;
-  _transport = null;
+  notificationHandlers = [];
+  rootsCache = [];
+  constructor(opts = {}) {
+    this.opts = opts;
+    if (opts.roots) {
+      this.rootsCache = [...opts.roots];
+    }
+  }
   /**
-   * Create a Streamable HTTP connection manager.
+   * Register a handler for server notifications
    *
-   * @param url  The HTTP endpoint URL.
-   * @param opts Optional transport options (auth, headers, etc.).
+   * @param handler - Function to call when a notification is received
+   *
+   * @example
+   * ```typescript
+   * connector.onNotification((notification) => {
+   *   console.log(`Received: ${notification.method}`, notification.params);
+   * });
+   * ```
    */
-  constructor(url, opts) {
-    super();
-    this.url = typeof url === "string" ? new URL(url) : url;
-    this.opts = opts;
+  onNotification(handler) {
+    this.notificationHandlers.push(handler);
+    if (this.client) {
+      this.setupNotificationHandler();
+    }
   }
   /**
-   * Spawn a new `StreamableHTTPClientTransport` and return it.
-   * The Client.connect() method will handle starting the transport.
+   * Internal: wire notification handlers to the SDK client
+   * Includes automatic handling for list_changed notifications per MCP spec
    */
-  async establishConnection() {
-    this._transport = new import_streamableHttp.StreamableHTTPClientTransport(this.url, this.opts);
-    logger.debug(`${this.constructor.name} created successfully`);
-    return this._transport;
+  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);
+        }
+      }
+    };
   }
   /**
-   * Close the underlying transport and clean up resources.
+   * Auto-refresh tools cache when server sends tools/list_changed notification
    */
-  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;
-      }
+  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);
     }
   }
   /**
-   * Get the session ID from the transport if available.
+   * Called when server sends resources/list_changed notification
+   * Resources aren't cached by default, but we log for user awareness
    */
-  get sessionId() {
-    return this._transport?.sessionId;
+  async onResourcesListChanged() {
+    logger.debug(
+      "[Auto] Resources list changed - clients should re-fetch if needed"
+    );
   }
-};
-
-// src/connectors/base.ts
-init_logging();
-var BaseConnector = class {
-  static {
-    __name(this, "BaseConnector");
+  /**
+   * 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"
+    );
   }
-  client = null;
-  connectionManager = null;
-  toolsCache = null;
-  capabilitiesCache = null;
-  serverInfoCache = null;
-  connected = false;
-  opts;
-  constructor(opts = {}) {
-    this.opts = opts;
+  /**
+   * 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(
+      import_types.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(
+      import_types.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() {
@@ -1495,6 +1592,7 @@ var HttpConnector = class extends BaseConnector {
   clientInfo;
   preferSse;
   transportType = null;
+  streamableTransport = null;
   constructor(baseUrl, opts = {}) {
     super(opts);
     this.baseUrl = baseUrl.replace(/\/$/, "");
@@ -1530,7 +1628,7 @@ var HttpConnector = class extends BaseConnector {
     } catch (err) {
       let fallbackReason = "Unknown error";
       let is401Error = false;
-      if (err instanceof import_streamableHttp2.StreamableHTTPError) {
+      if (err instanceof import_streamableHttp.StreamableHTTPError) {
         is401Error = err.code === 401;
         if (err.code === 400 && err.message.includes("Missing session ID")) {
           fallbackReason = "Server requires session ID (FastMCP compatibility) - using SSE transport";
@@ -1586,34 +1684,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 import_streamableHttp.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 import_client.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 import_client.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;
@@ -1621,8 +1752,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}`
       );
@@ -1643,10 +1790,28 @@ var HttpConnector = class extends BaseConnector {
         const serverId = this.baseUrl;
         transport = this.opts.wrapTransport(transport, serverId);
       }
-      this.client = new import_client.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 import_client.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}`
       );
@@ -1822,6 +1987,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);
       }
@@ -1852,6 +2020,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");
@@ -1931,6 +2142,51 @@ 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/client/base.ts
@@ -2066,7 +2322,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");
     }
@@ -2075,9 +2340,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/src/browser.d.ts

@@ -6,9 +6,11 @@ export { MCPAgent } from "./agents/mcp_agent.js";
 export { RemoteAgent } from "./agents/remote.js";
 export { BaseAdapter, LangChainAdapter } from "./adapters/index.js";
 export { BaseConnector } from "./connectors/base.js";
+export type { NotificationHandler } from "./connectors/base.js";
 export { HttpConnector } from "./connectors/http.js";
 export { WebSocketConnector } from "./connectors/websocket.js";
 export { MCPSession } from "./session.js";
+export type { Notification, Root } from "./session.js";
 export { BrowserOAuthClientProvider } from "./auth/browser-provider.js";
 export { onMcpAuthorization } from "./auth/callback.js";
 export type { StoredState } from "./auth/types.js";