mcp-use 1.11.0-canary.8 → 1.11.0

package/dist/chunk-UWWLWLS2.js

@@ -0,0 +1,62 @@
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
+
+// src/server/utils/jsonrpc-helpers.ts
+function createNotification(method, params) {
+  return {
+    jsonrpc: "2.0",
+    method,
+    ...params && { params }
+  };
+}
+__name(createNotification, "createNotification");
+function createRequest(id, method, params) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    method,
+    ...params && { params }
+  };
+}
+__name(createRequest, "createRequest");
+
+// src/server/sessions/notifications.ts
+async function sendNotificationToAll(sessions, method, params) {
+  const notification = createNotification(method, params);
+  for (const [sessionId, session] of sessions.entries()) {
+    try {
+      await session.transport.send(notification);
+    } catch (error) {
+      console.warn(
+        `[MCP] Failed to send notification to session ${sessionId}:`,
+        error
+      );
+    }
+  }
+}
+__name(sendNotificationToAll, "sendNotificationToAll");
+async function sendNotificationToSession(sessions, sessionId, method, params) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    return false;
+  }
+  const notification = createNotification(method, params);
+  try {
+    await session.transport.send(notification);
+    return true;
+  } catch (error) {
+    console.warn(
+      `[MCP] Failed to send notification to session ${sessionId}:`,
+      error
+    );
+    return false;
+  }
+}
+__name(sendNotificationToSession, "sendNotificationToSession");
+
+export {
+  createRequest,
+  sendNotificationToAll,
+  sendNotificationToSession
+};

package/dist/{chunk-ZFZPZ4GE.js → chunk-V77WS6CS.js}

@@ -1,7 +1,15 @@
+import {
+  CODE_MODE_AGENT_PROMPT
+} from "./chunk-QPIDKGV4.js";
 import {
   __name
 } from "./chunk-3GQAWCBQ.js";
 
+// src/agents/prompts/index.ts
+var PROMPTS = {
+  CODE_MODE: CODE_MODE_AGENT_PROMPT
+};
+
 // src/agents/base.ts
 var BaseAgent = class {
   static {
@@ -17,5 +25,6 @@ var BaseAgent = class {
 };
 
 export {
+  PROMPTS,
   BaseAgent
 };

package/dist/{chunk-EBSNALCB.js → chunk-VRHAF2WT.js}

@@ -1,11 +1,11 @@
 import {
   BaseMCPClient,
   HttpConnector
-} from "./chunk-TAEHPLGV.js";
+} from "./chunk-GN5HOAV3.js";
 import {
   Tel,
   getPackageVersion
-} from "./chunk-JPKFN73V.js";
+} from "./chunk-ZLZOOXMJ.js";
 import {
   logger
 } from "./chunk-FRUZDWXH.js";
@@ -63,7 +63,9 @@ var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
       wrapTransport,
       clientOptions,
       samplingCallback,
-      elicitationCallback
+      elicitationCallback,
+      disableSseFallback,
+      preferSse
     } = serverConfig;
     if (!url) {
       throw new Error("Server URL is required");
@@ -79,8 +81,12 @@ var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
       // ← Pass client options (capabilities, etc.) to connector
       samplingCallback,
       // ← Pass sampling callback to connector
-      elicitationCallback
+      elicitationCallback,
       // ← Pass elicitation callback to connector
+      disableSseFallback,
+      // ← Disable automatic SSE fallback
+      preferSse
+      // ← Use SSE transport directly
     };
     if (clientOptions) {
       console.log(

package/dist/{chunk-X7JKFBPN.js → chunk-Y2HHHJQB.js}

@@ -1,13 +1,13 @@
 import {
   BrowserMCPClient
-} from "./chunk-EBSNALCB.js";
+} from "./chunk-VRHAF2WT.js";
+import {
+  Tel
+} from "./chunk-ZLZOOXMJ.js";
 import {
   BrowserOAuthClientProvider,
   sanitizeUrl
 } from "./chunk-J75I2C26.js";
-import {
-  Tel
-} from "./chunk-JPKFN73V.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);
@@ -202,7 +207,12 @@ function useMcp(options) {
         const serverName = "inspector-server";
         const serverConfig = {
           url,
-          transport: transportTypeParam === "sse" ? "http" : transportTypeParam
+          transport: transportTypeParam === "sse" ? "http" : transportTypeParam,
+          // Disable SSE fallback when using explicit HTTP transport (not SSE)
+          // This prevents automatic HTTP → SSE fallback at the connector level
+          disableSseFallback: transportTypeParam === "http",
+          // Use SSE transport when explicitly requested
+          preferSse: transportTypeParam === "sse"
         };
         if (customHeaders && Object.keys(customHeaders).length > 0) {
           serverConfig.headers = customHeaders;
@@ -240,9 +250,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 +284,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 +692,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 +907,10 @@ function useMcp(options) {
     listResources,
     listPrompts,
     getPrompt,
+    refreshTools,
+    refreshResources,
+    refreshPrompts,
+    refreshAll,
     retry,
     disconnect,
     authenticate,

package/dist/{chunk-JPKFN73V.js → chunk-ZLZOOXMJ.js}

@@ -92,7 +92,7 @@ function generateUUID() {
 __name(generateUUID, "generateUUID");
 
 // src/version.ts
-var VERSION = "1.11.0-canary.8";
+var VERSION = "1.11.0";
 function getPackageVersion() {
   return VERSION;
 }
@@ -479,6 +479,20 @@ function extractModelInfo(llm) {
 __name(extractModelInfo, "extractModelInfo");
 
 // src/telemetry/telemetry.ts
+function secureRandomString() {
+  if (typeof window !== "undefined" && window.crypto && typeof window.crypto.getRandomValues === "function") {
+    const array = new Uint8Array(8);
+    window.crypto.getRandomValues(array);
+    return Array.from(array, (v) => v.toString(16).padStart(2, "0")).join("");
+  }
+  try {
+    const crypto = __require("crypto");
+    return crypto.randomBytes(8).toString("hex");
+  } catch (e) {
+    return Math.random().toString(36).substring(2, 15);
+  }
+}
+__name(secureRandomString, "secureRandomString");
 var USER_ID_STORAGE_KEY = "mcp_use_user_id";
 function detectRuntimeEnvironment() {
   try {
@@ -610,12 +624,26 @@ var Telemetry = class _Telemetry {
         "Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable."
       );
       this._posthogLoading = this._initPostHog();
-      try {
-        this._scarfClient = new ScarfEventLogger(this.SCARF_GATEWAY_URL, 3e3);
-      } catch (e) {
-        logger.warn(`Failed to initialize Scarf telemetry: ${e}`);
+      if (this._runtimeEnvironment !== "browser") {
+        try {
+          this._scarfClient = new ScarfEventLogger(
+            this.SCARF_GATEWAY_URL,
+            3e3
+          );
+        } catch (e) {
+          logger.warn(`Failed to initialize Scarf telemetry: ${e}`);
+          this._scarfClient = null;
+        }
+      } else {
         this._scarfClient = null;
       }
+      if (this._storageCapability === "filesystem" && this._scarfClient) {
+        setTimeout(() => {
+          this.trackPackageDownload({ triggered_by: "initialization" }).catch(
+            (e) => logger.debug(`Failed to track package download: ${e}`)
+          );
+        }, 0);
+      }
     }
   }
   _checkTelemetryDisabled() {
@@ -740,47 +768,65 @@ var Telemetry = class _Telemetry {
           break;
         case "session-only":
         default:
-          this._currUserId = `session-${generateUUID()}`;
-          logger.debug(
-            `Using session-based user ID (${this._runtimeEnvironment} environment)`
-          );
+          try {
+            this._currUserId = `session-${generateUUID()}`;
+          } catch (uuidError) {
+            this._currUserId = `session-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+          }
           break;
       }
-      if (this._storageCapability === "filesystem" && this._currUserId) {
-        this._trackPackageDownloadInternal(this._currUserId, {
-          triggered_by: "user_id_property"
-        }).catch((e) => logger.debug(`Failed to track package download: ${e}`));
-      }
     } catch (e) {
-      logger.debug(`Failed to get/create user ID: ${e}`);
       this._currUserId = this.UNKNOWN_USER_ID;
     }
     return this._currUserId;
   }
   /**
    * Get or create user ID from filesystem (Node.js/Bun)
+   * Falls back to session ID if filesystem operations fail
    */
   _getUserIdFromFilesystem() {
-    const fs = __require("fs");
-    const os = __require("os");
-    const path = __require("path");
-    if (!this._userIdPath) {
-      this._userIdPath = path.join(
-        this._getCacheHome(os, path),
-        "mcp_use_3",
-        "telemetry_user_id"
-      );
-    }
-    const isFirstTime = !fs.existsSync(this._userIdPath);
-    if (isFirstTime) {
-      logger.debug(`Creating user ID path: ${this._userIdPath}`);
-      fs.mkdirSync(path.dirname(this._userIdPath), { recursive: true });
-      const newUserId = generateUUID();
-      fs.writeFileSync(this._userIdPath, newUserId);
-      logger.debug(`User ID path created: ${this._userIdPath}`);
-      return newUserId;
+    try {
+      let fs, os, path;
+      try {
+        fs = __require("fs");
+        os = __require("os");
+        path = __require("path");
+      } catch (requireError) {
+        try {
+          const sessionId = `session-${generateUUID()}`;
+          return sessionId;
+        } catch (uuidError) {
+          return `session-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+        }
+      }
+      if (!this._userIdPath) {
+        this._userIdPath = path.join(
+          this._getCacheHome(os, path),
+          "mcp_use_3",
+          "telemetry_user_id"
+        );
+      }
+      const isFirstTime = !fs.existsSync(this._userIdPath);
+      if (isFirstTime) {
+        fs.mkdirSync(path.dirname(this._userIdPath), { recursive: true });
+        let newUserId;
+        try {
+          newUserId = generateUUID();
+        } catch (uuidError) {
+          newUserId = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+        }
+        fs.writeFileSync(this._userIdPath, newUserId);
+        return newUserId;
+      }
+      const userId = fs.readFileSync(this._userIdPath, "utf-8").trim();
+      return userId;
+    } catch (e) {
+      try {
+        return `session-${generateUUID()}`;
+      } catch (uuidError) {
+        return `session-${Date.now()}-${secureRandomString()}`;
+      }
     }
-    return fs.readFileSync(this._userIdPath, "utf-8").trim();
   }
   /**
    * Get or create user ID from localStorage (Browser)
@@ -789,14 +835,22 @@ var Telemetry = class _Telemetry {
     try {
       let userId = localStorage.getItem(USER_ID_STORAGE_KEY);
       if (!userId) {
-        userId = generateUUID();
+        try {
+          userId = generateUUID();
+        } catch (uuidError) {
+          userId = `${Date.now()}-${secureRandomString()}`;
+        }
         localStorage.setItem(USER_ID_STORAGE_KEY, userId);
-        logger.debug(`Created new browser user ID`);
       }
       return userId;
     } catch (e) {
-      logger.debug(`localStorage access failed: ${e}`);
-      return `session-${generateUUID()}`;
+      let sessionId;
+      try {
+        sessionId = `session-${generateUUID()}`;
+      } catch (uuidError) {
+        sessionId = `session-${Date.now()}-${secureRandomString()}`;
+      }
+      return sessionId;
     }
   }
   _getCacheHome(os, path) {
@@ -825,6 +879,7 @@ var Telemetry = class _Telemetry {
     if (!this._posthogNodeClient && !this._posthogBrowserClient && !this._scarfClient) {
       return;
     }
+    const currentUserId = this.userId;
     const properties = { ...event.properties };
     properties.mcp_use_version = getPackageVersion();
     properties.language = "typescript";
@@ -832,9 +887,8 @@ var Telemetry = class _Telemetry {
     properties.runtime = this._runtimeEnvironment;
     if (this._posthogNodeClient) {
       try {
-        logger.debug(`CAPTURE: PostHog Node Event ${event.name}`);
         this._posthogNodeClient.capture({
-          distinctId: this.userId,
+          distinctId: currentUserId,
           event: event.name,
           properties
         });
@@ -844,10 +898,9 @@ var Telemetry = class _Telemetry {
     }
     if (this._posthogBrowserClient) {
       try {
-        logger.debug(`CAPTURE: PostHog Browser Event ${event.name}`);
         this._posthogBrowserClient.capture(event.name, {
           ...properties,
-          distinct_id: this.userId
+          distinct_id: currentUserId
         });
       } catch (e) {
         logger.debug(
@@ -859,7 +912,7 @@ var Telemetry = class _Telemetry {
       try {
         const scarfProperties = {
           ...properties,
-          user_id: this.userId,
+          user_id: currentUserId,
           event: event.name
         };
         await this._scarfClient.logEvent(scarfProperties);