mcp-use 1.11.0-canary.7 → 1.11.0-canary.9

package/dist/{chunk-WTGUJLTR.js → chunk-F3BZFJCD.js}

@@ -1,13 +1,13 @@
 import {
   BrowserMCPClient
-} from "./chunk-REYY7LSD.js";
+} from "./chunk-5QFJZ7H3.js";
 import {
   BrowserOAuthClientProvider,
   sanitizeUrl
 } from "./chunk-J75I2C26.js";
 import {
   Tel
-} from "./chunk-3QVRNWW7.js";
+} from "./chunk-Q5LZL6BH.js";
 import {
   __name
 } from "./chunk-3GQAWCBQ.js";
@@ -101,6 +101,11 @@ function useMcp(options) {
       if (clientRef.current) {
         try {
           const serverName = "inspector-server";
+          const session = clientRef.current.getSession(serverName);
+          if (session && session._healthCheckCleanup) {
+            session._healthCheckCleanup();
+            session._healthCheckCleanup = null;
+          }
           await clientRef.current.closeSession(serverName);
         } catch (err) {
           if (!quiet) addLog("warn", "Error closing session:", err);
@@ -240,9 +245,25 @@ function useMcp(options) {
           serverName,
           false
         );
-        if (onNotification) {
-          session.on("notification", onNotification);
-        }
+        session.on("notification", (notification) => {
+          onNotification?.(notification);
+          if (notification.method === "notifications/tools/list_changed") {
+            addLog("info", "Tools list changed, auto-refreshing...");
+            refreshTools().catch(
+              (err) => addLog("warn", "Auto-refresh tools failed:", err)
+            );
+          } else if (notification.method === "notifications/resources/list_changed") {
+            addLog("info", "Resources list changed, auto-refreshing...");
+            refreshResources().catch(
+              (err) => addLog("warn", "Auto-refresh resources failed:", err)
+            );
+          } else if (notification.method === "notifications/prompts/list_changed") {
+            addLog("info", "Prompts list changed, auto-refreshing...");
+            refreshPrompts().catch(
+              (err) => addLog("warn", "Auto-refresh prompts failed:", err)
+            );
+          }
+        });
         await session.initialize();
         addLog("info", "\u2705 Successfully connected to MCP server");
         addLog("info", "Server info:", session.connector.serverInfo);
@@ -258,6 +279,63 @@ function useMcp(options) {
         );
         setState("ready");
         successfulTransportRef.current = transportTypeParam;
+        const setupConnectionMonitoring = /* @__PURE__ */ __name(() => {
+          let healthCheckInterval = null;
+          let lastSuccessfulCheck = Date.now();
+          const HEALTH_CHECK_INTERVAL = 1e4;
+          const HEALTH_CHECK_TIMEOUT = 3e4;
+          const checkConnectionHealth = /* @__PURE__ */ __name(async () => {
+            if (!isMountedRef.current || stateRef.current !== "ready") {
+              if (healthCheckInterval) {
+                clearInterval(healthCheckInterval);
+                healthCheckInterval = null;
+              }
+              return;
+            }
+            try {
+              await session.connector.listTools();
+              lastSuccessfulCheck = Date.now();
+            } catch (err) {
+              const timeSinceLastSuccess = Date.now() - lastSuccessfulCheck;
+              if (timeSinceLastSuccess > HEALTH_CHECK_TIMEOUT) {
+                addLog(
+                  "warn",
+                  `Connection appears to be broken (no response for ${Math.round(timeSinceLastSuccess / 1e3)}s), attempting to reconnect...`
+                );
+                if (healthCheckInterval) {
+                  clearInterval(healthCheckInterval);
+                  healthCheckInterval = null;
+                }
+                if (autoReconnectRef.current && isMountedRef.current) {
+                  setState("discovering");
+                  addLog("info", "Auto-reconnecting to MCP server...");
+                  setTimeout(
+                    () => {
+                      if (isMountedRef.current && stateRef.current === "discovering") {
+                        connect();
+                      }
+                    },
+                    typeof autoReconnectRef.current === "number" ? autoReconnectRef.current : DEFAULT_RECONNECT_DELAY
+                  );
+                }
+              }
+            }
+          }, "checkConnectionHealth");
+          healthCheckInterval = setInterval(
+            checkConnectionHealth,
+            HEALTH_CHECK_INTERVAL
+          );
+          return () => {
+            if (healthCheckInterval) {
+              clearInterval(healthCheckInterval);
+              healthCheckInterval = null;
+            }
+          };
+        }, "setupConnectionMonitoring");
+        if (autoReconnect) {
+          const cleanup = setupConnectionMonitoring();
+          session._healthCheckCleanup = cleanup;
+        }
         Tel.getInstance().trackUseMcpConnection({
           url,
           transportType: transportTypeParam,
@@ -609,6 +687,70 @@ function useMcp(options) {
       throw err;
     }
   }, [state]);
+  const refreshTools = useCallback(async () => {
+    if (stateRef.current !== "ready" || !clientRef.current) {
+      addLog("debug", "Cannot refresh tools - client not ready");
+      return;
+    }
+    addLog("debug", "Refreshing tools list");
+    try {
+      const serverName = "inspector-server";
+      const session = clientRef.current.getSession(serverName);
+      if (!session) {
+        addLog("warn", "No active session found for tools refresh");
+        return;
+      }
+      const toolsResult = await session.connector.listTools();
+      setTools(toolsResult || []);
+      addLog("info", "Tools list refreshed successfully");
+    } catch (err) {
+      addLog("warn", "Failed to refresh tools:", err);
+    }
+  }, [addLog]);
+  const refreshResources = useCallback(async () => {
+    if (stateRef.current !== "ready" || !clientRef.current) {
+      addLog("debug", "Cannot refresh resources - client not ready");
+      return;
+    }
+    addLog("debug", "Refreshing resources list");
+    try {
+      const serverName = "inspector-server";
+      const session = clientRef.current.getSession(serverName);
+      if (!session) {
+        addLog("warn", "No active session found for resources refresh");
+        return;
+      }
+      const resourcesResult = await session.connector.listAllResources();
+      setResources(resourcesResult.resources || []);
+      addLog("info", "Resources list refreshed successfully");
+    } catch (err) {
+      addLog("warn", "Failed to refresh resources:", err);
+    }
+  }, [addLog]);
+  const refreshPrompts = useCallback(async () => {
+    if (stateRef.current !== "ready" || !clientRef.current) {
+      addLog("debug", "Cannot refresh prompts - client not ready");
+      return;
+    }
+    addLog("debug", "Refreshing prompts list");
+    try {
+      const serverName = "inspector-server";
+      const session = clientRef.current.getSession(serverName);
+      if (!session) {
+        addLog("warn", "No active session found for prompts refresh");
+        return;
+      }
+      const promptsResult = await session.connector.listPrompts();
+      setPrompts(promptsResult.prompts || []);
+      addLog("info", "Prompts list refreshed successfully");
+    } catch (err) {
+      addLog("warn", "Failed to refresh prompts:", err);
+    }
+  }, [addLog]);
+  const refreshAll = useCallback(async () => {
+    addLog("info", "Refreshing all lists (tools, resources, prompts)");
+    await Promise.all([refreshTools(), refreshResources(), refreshPrompts()]);
+  }, [refreshTools, refreshResources, refreshPrompts, addLog]);
   const getPrompt = useCallback(
     async (name, args) => {
       if (stateRef.current !== "ready" || !clientRef.current) {
@@ -760,6 +902,10 @@ function useMcp(options) {
     listResources,
     listPrompts,
     getPrompt,
+    refreshTools,
+    refreshResources,
+    refreshPrompts,
+    refreshAll,
     retry,
     disconnect,
     authenticate,
@@ -907,6 +1053,15 @@ function useWidget(defaultProps) {
   const toolInput = provider === "openai" ? useOpenAiGlobal("toolInput") : urlParams.toolInput;
   const toolOutput = provider === "openai" ? useOpenAiGlobal("toolOutput") : urlParams.toolOutput;
   const toolResponseMetadata = useOpenAiGlobal("toolResponseMetadata");
+  const widgetProps = useMemo(() => {
+    if (toolResponseMetadata && typeof toolResponseMetadata === "object") {
+      const metaProps = toolResponseMetadata["mcp-use/props"];
+      if (metaProps) {
+        return metaProps;
+      }
+    }
+    return defaultProps || {};
+  }, [toolResponseMetadata, defaultProps]);
   const widgetState = useOpenAiGlobal("widgetState");
   const theme = useOpenAiGlobal("theme");
   const displayMode = useOpenAiGlobal("displayMode");
@@ -971,9 +1126,13 @@ function useWidget(defaultProps) {
     },
     [widgetState, localWidgetState]
   );
+  const isPending = useMemo(() => {
+    return provider === "openai" && toolResponseMetadata === null;
+  }, [provider, toolResponseMetadata]);
   return {
     // Props and state (with defaults)
-    props: toolInput || defaultProps || {},
+    props: widgetProps,
+    toolInput: toolInput || {},
     output: toolOutput ?? null,
     metadata: toolResponseMetadata ?? null,
     state: localWidgetState,
@@ -995,7 +1154,8 @@ function useWidget(defaultProps) {
     openExternal,
     requestDisplayMode,
     // Availability
-    isAvailable: isOpenAiAvailable
+    isAvailable: isOpenAiAvailable,
+    isPending
   };
 }
 __name(useWidget, "useWidget");

package/dist/{chunk-QP7MQ2UJ.js → chunk-HU2DGJ5J.js}

@@ -1,9 +1,9 @@
 import {
   BaseConnector
-} from "./chunk-CHHWJQVC.js";
+} from "./chunk-XEFWIBQF.js";
 import {
   Tel
-} from "./chunk-3QVRNWW7.js";
+} from "./chunk-Q5LZL6BH.js";
 import {
   logger
 } from "./chunk-FRUZDWXH.js";
@@ -284,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 {
@@ -419,6 +547,7 @@ var SseConnectionManager = class extends ConnectionManager {
   url;
   opts;
   _transport = null;
+  reinitializing = false;
   /**
    * Create an SSE connection manager.
    *
@@ -431,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.
@@ -727,134 +897,6 @@ var HttpConnector = class extends BaseConnector {
   }
 };
 
-// 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");
-    }
-  }
-};
-
 export {
   MCPSession,
   BaseMCPClient,

package/dist/{chunk-REX2YTWF.js → chunk-M7WATKYM.js}

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