mcp-use 1.10.0-canary.10 → 1.10.0-canary.11

package/dist/src/react/index.cjs

@@ -31,12 +31,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/react/index.ts
 var react_exports = {};
 __export(react_exports, {
+  BrowserTelemetry: () => Tel,
   ErrorBoundary: () => ErrorBoundary,
   Image: () => Image,
   McpUseProvider: () => McpUseProvider,
+  Tel: () => Tel,
+  Telemetry: () => Telemetry,
   ThemeProvider: () => ThemeProvider,
   WidgetControls: () => WidgetControls,
   onMcpAuthorization: () => onMcpAuthorization,
+  setBrowserTelemetrySource: () => setTelemetrySource,
+  setTelemetrySource: () => setTelemetrySource,
   useMcp: () => useMcp,
   useWidget: () => useWidget,
   useWidgetProps: () => useWidgetProps,
@@ -82,9 +87,9 @@ var import_streamableHttp = require("@mcp-use/modelcontextprotocol-sdk/client/st
 async function getNodeModules() {
   if (typeof process !== "undefined" && process.platform) {
     try {
-      const fs2 = await import("fs");
-      const path2 = await import("path");
-      return { fs: fs2.default, path: path2.default };
+      const fs = await import("fs");
+      const path = await import("path");
+      return { fs: fs.default, path: path.default };
     } catch {
       return { fs: null, path: null };
     }
@@ -515,19 +520,6 @@ var SseConnectionManager = class extends ConnectionManager {
 // src/connectors/base.ts
 var import_types = require("@mcp-use/modelcontextprotocol-sdk/types.js");
 
-// src/telemetry/telemetry.ts
-var fs = __toESM(require("fs"), 1);
-var os = __toESM(require("os"), 1);
-var path = __toESM(require("path"), 1);
-var import_posthog_node = require("posthog-node");
-
-// src/server/utils/runtime.ts
-var isDeno = typeof globalThis.Deno !== "undefined";
-function generateUUID() {
-  return globalThis.crypto.randomUUID();
-}
-__name(generateUUID, "generateUUID");
-
 // src/telemetry/events.ts
 var BaseTelemetryEvent = class {
   static {
@@ -803,7 +795,8 @@ var MCPClientInitEvent = class extends BaseTelemetryEvent {
       all_callbacks: this.data.allCallbacks,
       verify: this.data.verify,
       servers: this.data.servers,
-      num_servers: this.data.numServers
+      num_servers: this.data.numServers,
+      is_browser: this.data.isBrowser
     };
   }
 };
@@ -828,9 +821,62 @@ var ConnectorInitEvent = class extends BaseTelemetryEvent {
     };
   }
 };
+var ClientAddServerEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ClientAddServerEvent");
+  }
+  get name() {
+    return "client_add_server";
+  }
+  get properties() {
+    const { serverName, serverConfig } = this.data;
+    const url = serverConfig.url;
+    return {
+      server_name: serverName,
+      server_url_domain: url ? this._extractHostname(url) : null,
+      transport: serverConfig.transport ?? null,
+      has_auth: !!(serverConfig.authToken || serverConfig.authProvider)
+    };
+  }
+  _extractHostname(url) {
+    try {
+      return new URL(url).hostname;
+    } catch {
+      return null;
+    }
+  }
+};
+var ClientRemoveServerEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ClientRemoveServerEvent");
+  }
+  get name() {
+    return "client_remove_server";
+  }
+  get properties() {
+    return {
+      server_name: this.data.serverName
+    };
+  }
+};
+
+// src/server/utils/runtime.ts
+var isDeno = typeof globalThis.Deno !== "undefined";
+function generateUUID() {
+  return globalThis.crypto.randomUUID();
+}
+__name(generateUUID, "generateUUID");
 
 // src/version.ts
-var VERSION = "1.10.0-canary.10";
+var VERSION = "1.10.0-canary.11";
 function getPackageVersion() {
   return VERSION;
 }
@@ -852,12 +898,12 @@ function detectRuntimeEnvironment() {
     if (typeof globalThis.EdgeRuntime !== "undefined") {
       return "edge";
     }
-    if (typeof process !== "undefined" && typeof process.versions?.node !== "undefined" && typeof fs !== "undefined" && typeof fs.existsSync === "function") {
-      return "node";
-    }
     if (typeof window !== "undefined" && typeof document !== "undefined") {
       return "browser";
     }
+    if (typeof process !== "undefined" && typeof process.versions?.node !== "undefined") {
+      return "node";
+    }
     return "unknown";
   } catch {
     return "unknown";
@@ -894,11 +940,6 @@ function getRuntimeEnvironment() {
   return cachedEnvironment;
 }
 __name(getRuntimeEnvironment, "getRuntimeEnvironment");
-function isNodeJSEnvironment2() {
-  const env = getRuntimeEnvironment();
-  return env === "node" || env === "bun";
-}
-__name(isNodeJSEnvironment2, "isNodeJSEnvironment");
 var ScarfEventLogger = class {
   static {
     __name(this, "ScarfEventLogger");
@@ -930,71 +971,40 @@ var ScarfEventLogger = class {
     }
   }
 };
-function getCacheHome() {
-  if (!isNodeJSEnvironment2()) {
-    return "/tmp/mcp_use_cache";
-  }
-  const envVar = process.env.XDG_CACHE_HOME;
-  if (envVar && path.isAbsolute(envVar)) {
-    return envVar;
-  }
-  const platform = process.platform;
-  const homeDir = os.homedir();
-  if (platform === "win32") {
-    const appdata = process.env.LOCALAPPDATA || process.env.APPDATA;
-    if (appdata) {
-      return appdata;
-    }
-    return path.join(homeDir, "AppData", "Local");
-  } else if (platform === "darwin") {
-    return path.join(homeDir, "Library", "Caches");
-  } else {
-    return path.join(homeDir, ".cache");
-  }
-}
-__name(getCacheHome, "getCacheHome");
 var Telemetry = class _Telemetry {
   static {
     __name(this, "Telemetry");
   }
   static instance = null;
-  USER_ID_PATH = path.join(
-    getCacheHome(),
-    "mcp_use_3",
-    "telemetry_user_id"
-  );
-  VERSION_DOWNLOAD_PATH = path.join(
-    getCacheHome(),
-    "mcp_use",
-    "download_version"
-  );
   PROJECT_API_KEY = "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI";
   HOST = "https://eu.i.posthog.com";
   SCARF_GATEWAY_URL = "https://mcpuse.gateway.scarf.sh/events-ts";
   UNKNOWN_USER_ID = "UNKNOWN_USER_ID";
   _currUserId = null;
-  _posthogClient = null;
+  _posthogNodeClient = null;
+  _posthogBrowserClient = null;
+  _posthogLoading = null;
   _scarfClient = null;
   _runtimeEnvironment;
   _storageCapability;
   _source;
+  // Node.js specific paths (lazily computed)
+  _userIdPath = null;
+  _versionDownloadPath = null;
   constructor() {
     this._runtimeEnvironment = getRuntimeEnvironment();
     this._storageCapability = getStorageCapability(this._runtimeEnvironment);
     this._source = typeof process !== "undefined" && process.env?.MCP_USE_TELEMETRY_SOURCE || this._runtimeEnvironment;
-    const telemetryDisabled = typeof process !== "undefined" && process.env?.MCP_USE_ANONYMIZED_TELEMETRY?.toLowerCase() === "false" || false;
+    const telemetryDisabled = this._checkTelemetryDisabled();
     const canSupportTelemetry = this._runtimeEnvironment !== "unknown";
-    const isServerlessEnvironment = [
-      "cloudflare-workers",
-      "edge",
-      "deno"
-    ].includes(this._runtimeEnvironment);
     if (telemetryDisabled) {
-      this._posthogClient = null;
+      this._posthogNodeClient = null;
+      this._posthogBrowserClient = null;
       this._scarfClient = null;
-      logger.debug("Telemetry disabled via environment variable");
+      logger.debug("Telemetry disabled via environment/localStorage");
     } else if (!canSupportTelemetry) {
-      this._posthogClient = null;
+      this._posthogNodeClient = null;
+      this._posthogBrowserClient = null;
       this._scarfClient = null;
       logger.debug(
         `Telemetry disabled - unknown environment: ${this._runtimeEnvironment}`
@@ -1003,27 +1013,7 @@ var Telemetry = class _Telemetry {
       logger.info(
         "Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable."
       );
-      if (this._runtimeEnvironment !== "browser") {
-        try {
-          const posthogOptions = {
-            host: this.HOST,
-            disableGeoip: false
-          };
-          if (isServerlessEnvironment) {
-            posthogOptions.flushAt = 1;
-            posthogOptions.flushInterval = 0;
-          }
-          this._posthogClient = new import_posthog_node.PostHog(
-            this.PROJECT_API_KEY,
-            posthogOptions
-          );
-        } catch (e) {
-          logger.warn(`Failed to initialize PostHog telemetry: ${e}`);
-          this._posthogClient = null;
-        }
-      } else {
-        this._posthogClient = null;
-      }
+      this._posthogLoading = this._initPostHog();
       try {
         this._scarfClient = new ScarfEventLogger(this.SCARF_GATEWAY_URL, 3e3);
       } catch (e) {
@@ -1032,6 +1022,75 @@ var Telemetry = class _Telemetry {
       }
     }
   }
+  _checkTelemetryDisabled() {
+    if (typeof process !== "undefined" && process.env?.MCP_USE_ANONYMIZED_TELEMETRY?.toLowerCase() === "false") {
+      return true;
+    }
+    if (typeof localStorage !== "undefined" && localStorage.getItem("MCP_USE_ANONYMIZED_TELEMETRY") === "false") {
+      return true;
+    }
+    return false;
+  }
+  async _initPostHog() {
+    const isBrowser = this._runtimeEnvironment === "browser";
+    if (isBrowser) {
+      await this._initPostHogBrowser();
+    } else {
+      await this._initPostHogNode();
+    }
+  }
+  async _initPostHogBrowser() {
+    try {
+      const posthogModule = await import("posthog-js");
+      const posthog = posthogModule.default || posthogModule.posthog;
+      if (!posthog || typeof posthog.init !== "function") {
+        throw new Error("posthog-js module did not export expected interface");
+      }
+      posthog.init(this.PROJECT_API_KEY, {
+        api_host: this.HOST,
+        persistence: "localStorage",
+        autocapture: false,
+        // We only want explicit captures
+        capture_pageview: false,
+        // We don't want automatic pageview tracking
+        disable_session_recording: true,
+        // No session recording
+        loaded: /* @__PURE__ */ __name(() => {
+          logger.debug("PostHog browser client initialized");
+        }, "loaded")
+      });
+      this._posthogBrowserClient = posthog;
+    } catch (e) {
+      logger.warn(`Failed to initialize PostHog browser telemetry: ${e}`);
+      this._posthogBrowserClient = null;
+    }
+  }
+  async _initPostHogNode() {
+    try {
+      const { PostHog } = await import("posthog-node");
+      const isServerlessEnvironment = [
+        "cloudflare-workers",
+        "edge",
+        "deno"
+      ].includes(this._runtimeEnvironment);
+      const posthogOptions = {
+        host: this.HOST,
+        disableGeoip: false
+      };
+      if (isServerlessEnvironment) {
+        posthogOptions.flushAt = 1;
+        posthogOptions.flushInterval = 0;
+      }
+      this._posthogNodeClient = new PostHog(
+        this.PROJECT_API_KEY,
+        posthogOptions
+      );
+      logger.debug("PostHog Node.js client initialized");
+    } catch (e) {
+      logger.warn(`Failed to initialize PostHog Node.js telemetry: ${e}`);
+      this._posthogNodeClient = null;
+    }
+  }
   /**
    * Get the detected runtime environment
    */
@@ -1067,10 +1126,9 @@ var Telemetry = class _Telemetry {
   }
   /**
    * Check if telemetry is enabled.
-   * Returns false if telemetry was disabled via environment variable or if not in Node.js environment.
    */
   get isEnabled() {
-    return this._posthogClient !== null || this._scarfClient !== null;
+    return this._posthogNodeClient !== null || this._posthogBrowserClient !== null || this._scarfClient !== null;
   }
   get userId() {
     if (this._currUserId) {
@@ -1079,10 +1137,10 @@ var Telemetry = class _Telemetry {
     try {
       switch (this._storageCapability) {
         case "filesystem":
-          this._currUserId = this.getUserIdFromFilesystem();
+          this._currUserId = this._getUserIdFromFilesystem();
           break;
         case "localStorage":
-          this._currUserId = this.getUserIdFromLocalStorage();
+          this._currUserId = this._getUserIdFromLocalStorage();
           break;
         case "session-only":
         default:
@@ -1093,7 +1151,7 @@ var Telemetry = class _Telemetry {
           break;
       }
       if (this._storageCapability === "filesystem" && this._currUserId) {
-        this.trackPackageDownloadInternal(this._currUserId, {
+        this._trackPackageDownloadInternal(this._currUserId, {
           triggered_by: "user_id_property"
         }).catch((e) => logger.debug(`Failed to track package download: ${e}`));
       }
@@ -1106,22 +1164,32 @@ var Telemetry = class _Telemetry {
   /**
    * Get or create user ID from filesystem (Node.js/Bun)
    */
-  getUserIdFromFilesystem() {
-    const isFirstTime = !fs.existsSync(this.USER_ID_PATH);
+  _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.USER_ID_PATH}`);
-      fs.mkdirSync(path.dirname(this.USER_ID_PATH), { recursive: true });
+      logger.debug(`Creating user ID path: ${this._userIdPath}`);
+      fs.mkdirSync(path.dirname(this._userIdPath), { recursive: true });
       const newUserId = generateUUID();
-      fs.writeFileSync(this.USER_ID_PATH, newUserId);
-      logger.debug(`User ID path created: ${this.USER_ID_PATH}`);
+      fs.writeFileSync(this._userIdPath, newUserId);
+      logger.debug(`User ID path created: ${this._userIdPath}`);
       return newUserId;
     }
-    return fs.readFileSync(this.USER_ID_PATH, "utf-8").trim();
+    return fs.readFileSync(this._userIdPath, "utf-8").trim();
   }
   /**
    * Get or create user ID from localStorage (Browser)
    */
-  getUserIdFromLocalStorage() {
+  _getUserIdFromLocalStorage() {
     try {
       let userId = localStorage.getItem(USER_ID_STORAGE_KEY);
       if (!userId) {
@@ -1135,60 +1203,89 @@ var Telemetry = class _Telemetry {
       return `session-${generateUUID()}`;
     }
   }
+  _getCacheHome(os, path) {
+    const envVar = process.env.XDG_CACHE_HOME;
+    if (envVar && path.isAbsolute(envVar)) {
+      return envVar;
+    }
+    const platform = process.platform;
+    const homeDir = os.homedir();
+    if (platform === "win32") {
+      const appdata = process.env.LOCALAPPDATA || process.env.APPDATA;
+      if (appdata) {
+        return appdata;
+      }
+      return path.join(homeDir, "AppData", "Local");
+    } else if (platform === "darwin") {
+      return path.join(homeDir, "Library", "Caches");
+    } else {
+      return path.join(homeDir, ".cache");
+    }
+  }
   async capture(event) {
-    logger.debug(
-      `CAPTURE: posthog: ${this._posthogClient !== null}, scarf: ${this._scarfClient !== null}`
-    );
-    if (!this._posthogClient && !this._scarfClient) {
+    if (this._posthogLoading) {
+      await this._posthogLoading;
+    }
+    if (!this._posthogNodeClient && !this._posthogBrowserClient && !this._scarfClient) {
       return;
     }
-    if (this._posthogClient) {
+    const properties = { ...event.properties };
+    properties.mcp_use_version = getPackageVersion();
+    properties.language = "typescript";
+    properties.source = this._source;
+    properties.runtime = this._runtimeEnvironment;
+    if (this._posthogNodeClient) {
       try {
-        const properties = { ...event.properties };
-        properties.mcp_use_version = getPackageVersion();
-        properties.language = "typescript";
-        properties.source = this._source;
-        properties.runtime = this._runtimeEnvironment;
-        logger.debug(`CAPTURE: PostHog Event ${event.name}`);
-        logger.debug(
-          `CAPTURE: PostHog Properties ${JSON.stringify(properties)}`
-        );
-        this._posthogClient.capture({
+        logger.debug(`CAPTURE: PostHog Node Event ${event.name}`);
+        this._posthogNodeClient.capture({
           distinctId: this.userId,
           event: event.name,
           properties
         });
       } catch (e) {
-        logger.debug(`Failed to track PostHog event ${event.name}: ${e}`);
+        logger.debug(`Failed to track PostHog Node event ${event.name}: ${e}`);
+      }
+    }
+    if (this._posthogBrowserClient) {
+      try {
+        logger.debug(`CAPTURE: PostHog Browser Event ${event.name}`);
+        this._posthogBrowserClient.capture(event.name, {
+          ...properties,
+          distinct_id: this.userId
+        });
+      } catch (e) {
+        logger.debug(
+          `Failed to track PostHog Browser event ${event.name}: ${e}`
+        );
       }
     }
     if (this._scarfClient) {
       try {
-        const properties = {};
-        properties.mcp_use_version = getPackageVersion();
-        properties.user_id = this.userId;
-        properties.event = event.name;
-        properties.language = "typescript";
-        properties.source = this._source;
-        properties.runtime = this._runtimeEnvironment;
-        await this._scarfClient.logEvent(properties);
+        const scarfProperties = {
+          ...properties,
+          user_id: this.userId,
+          event: event.name
+        };
+        await this._scarfClient.logEvent(scarfProperties);
       } catch (e) {
         logger.debug(`Failed to track Scarf event ${event.name}: ${e}`);
       }
     }
   }
+  // ============================================================================
+  // Package Download Tracking (Node.js only)
+  // ============================================================================
   /**
    * Track package download event.
    * This is a public wrapper that safely accesses userId.
    */
   async trackPackageDownload(properties) {
-    return this.trackPackageDownloadInternal(this.userId, properties);
+    return this._trackPackageDownloadInternal(this.userId, properties);
   }
   /**
    * Internal method to track package download with explicit userId.
-   * This avoids circular dependency when called from the userId getter.
    */
-  async trackPackageDownloadInternal(userId, properties) {
+  async _trackPackageDownloadInternal(userId, properties) {
     if (!this._scarfClient) {
       return;
     }
@@ -1196,22 +1293,32 @@ var Telemetry = class _Telemetry {
       return;
     }
     try {
+      const fs = require("fs");
+      const path = require("path");
+      const os = require("os");
+      if (!this._versionDownloadPath) {
+        this._versionDownloadPath = path.join(
+          this._getCacheHome(os, path),
+          "mcp_use",
+          "download_version"
+        );
+      }
       const currentVersion = getPackageVersion();
       let shouldTrack = false;
       let firstDownload = false;
-      if (!fs.existsSync(this.VERSION_DOWNLOAD_PATH)) {
+      if (!fs.existsSync(this._versionDownloadPath)) {
         shouldTrack = true;
         firstDownload = true;
-        fs.mkdirSync(path.dirname(this.VERSION_DOWNLOAD_PATH), {
+        fs.mkdirSync(path.dirname(this._versionDownloadPath), {
           recursive: true
         });
-        fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
+        fs.writeFileSync(this._versionDownloadPath, currentVersion);
       } else {
-        const savedVersion = fs.readFileSync(this.VERSION_DOWNLOAD_PATH, "utf-8").trim();
+        const savedVersion = fs.readFileSync(this._versionDownloadPath, "utf-8").trim();
         if (currentVersion > savedVersion) {
           shouldTrack = true;
           firstDownload = false;
-          fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
+          fs.writeFileSync(this._versionDownloadPath, currentVersion);
         }
       }
       if (shouldTrack) {
@@ -1245,9 +1352,6 @@ var Telemetry = class _Telemetry {
   // ============================================================================
   /**
    * Track server run event directly from an MCPServer instance.
-   * This extracts the necessary data from the server and creates the event.
-   * @param server - The MCPServer instance (or any object conforming to MCPServerTelemetryInfo)
-   * @param transport - The transport type (e.g., "http", "stdio", "supabase")
    */
   async trackServerRunFromServer(server, transport) {
     if (!this.isEnabled) return;
@@ -1293,33 +1397,125 @@ var Telemetry = class _Telemetry {
     const event = new ConnectorInitEvent(data);
     await this.capture(event);
   }
+  async trackClientAddServer(serverName, serverConfig) {
+    if (!this.isEnabled) return;
+    const event = new ClientAddServerEvent({ serverName, serverConfig });
+    await this.capture(event);
+  }
+  async trackClientRemoveServer(serverName) {
+    if (!this.isEnabled) return;
+    const event = new ClientRemoveServerEvent({ serverName });
+    await this.capture(event);
+  }
+  // ============================================================================
+  // React Hook / Browser specific events
+  // ============================================================================
+  async trackUseMcpConnection(data) {
+    if (!this.isEnabled) return;
+    await this.capture({
+      name: "usemcp_connection",
+      properties: {
+        url_domain: new URL(data.url).hostname,
+        // Only domain for privacy
+        transport_type: data.transportType,
+        success: data.success,
+        error_type: data.errorType ?? null,
+        connection_time_ms: data.connectionTimeMs ?? null,
+        has_oauth: data.hasOAuth,
+        has_sampling: data.hasSampling,
+        has_elicitation: data.hasElicitation
+      }
+    });
+  }
+  async trackUseMcpToolCall(data) {
+    if (!this.isEnabled) return;
+    await this.capture({
+      name: "usemcp_tool_call",
+      properties: {
+        tool_name: data.toolName,
+        success: data.success,
+        error_type: data.errorType ?? null,
+        execution_time_ms: data.executionTimeMs ?? null
+      }
+    });
+  }
+  async trackUseMcpResourceRead(data) {
+    if (!this.isEnabled) return;
+    await this.capture({
+      name: "usemcp_resource_read",
+      properties: {
+        resource_uri_scheme: data.resourceUri.split(":")[0],
+        // Only scheme for privacy
+        success: data.success,
+        error_type: data.errorType ?? null
+      }
+    });
+  }
+  // ============================================================================
+  // Browser-specific Methods
+  // ============================================================================
+  /**
+   * Identify the current user (useful for linking sessions)
+   * Browser only - no-op in Node.js
+   */
+  identify(userId, properties) {
+    if (this._posthogBrowserClient) {
+      try {
+        this._posthogBrowserClient.identify(userId, properties);
+      } catch (e) {
+        logger.debug(`Failed to identify user: ${e}`);
+      }
+    }
+  }
+  /**
+   * Reset the user identity (useful for logout)
+   * Browser only - no-op in Node.js
+   */
+  reset() {
+    if (this._posthogBrowserClient) {
+      try {
+        this._posthogBrowserClient.reset();
+      } catch (e) {
+        logger.debug(`Failed to reset user: ${e}`);
+      }
+    }
+    this._currUserId = null;
+  }
+  // ============================================================================
+  // Node.js-specific Methods
+  // ============================================================================
+  /**
+   * Flush the telemetry queue (Node.js only)
+   */
   flush() {
-    if (this._posthogClient) {
+    if (this._posthogNodeClient) {
       try {
-        this._posthogClient.flush();
+        this._posthogNodeClient.flush();
         logger.debug("PostHog client telemetry queue flushed");
       } catch (e) {
         logger.debug(`Failed to flush PostHog client: ${e}`);
       }
     }
-    if (this._scarfClient) {
-      logger.debug("Scarf telemetry events sent immediately (no flush needed)");
-    }
   }
+  /**
+   * Shutdown the telemetry client (Node.js only)
+   */
   shutdown() {
-    if (this._posthogClient) {
+    if (this._posthogNodeClient) {
       try {
-        this._posthogClient.shutdown();
+        this._posthogNodeClient.shutdown();
         logger.debug("PostHog client shutdown successfully");
       } catch (e) {
         logger.debug(`Error shutting down PostHog client: ${e}`);
       }
     }
-    if (this._scarfClient) {
-      logger.debug("Scarf telemetry client shutdown (no action needed)");
-    }
   }
 };
+var Tel = Telemetry;
+function setTelemetrySource(source) {
+  Tel.getInstance().setSource(source);
+}
+__name(setTelemetrySource, "setTelemetrySource");
 
 // src/connectors/base.ts
 var BaseConnector = class {
@@ -2602,11 +2798,13 @@ var BaseMCPClient = 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() {
@@ -2714,6 +2912,25 @@ var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
   }
   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);
@@ -3124,8 +3341,20 @@ function useMcp(options) {
         }
       }
       connectingRef.current = false;
+      if (url) {
+        Tel.getInstance().trackUseMcpConnection({
+          url,
+          transportType,
+          success: false,
+          errorType: connectionError?.name || "UnknownError",
+          hasOAuth: !!authProviderRef.current,
+          hasSampling: !!samplingCallback,
+          hasElicitation: !!onElicitation
+        }).catch(() => {
+        });
+      }
     },
-    [addLog]
+    [addLog, url, transportType, samplingCallback, onElicitation]
   );
   const connect = (0, import_react.useCallback)(async () => {
     if (!enabled || !url) {
@@ -3234,6 +3463,15 @@ function useMcp(options) {
         );
         setState("ready");
         successfulTransportRef.current = transportTypeParam;
+        Tel.getInstance().trackUseMcpConnection({
+          url,
+          transportType: transportTypeParam,
+          success: true,
+          hasOAuth: !!authProviderRef.current,
+          hasSampling: !!samplingCallback,
+          hasElicitation: !!onElicitation
+        }).catch(() => {
+        });
         setTools(session.connector.tools || []);
         const resourcesResult = await session.connector.listAllResources();
         setResources(resourcesResult.resources || []);
@@ -3358,6 +3596,7 @@ function useMcp(options) {
         );
       }
       addLog("info", `Calling tool: ${name}`, args);
+      const startTime = Date.now();
       try {
         const serverName = "inspector-server";
         const session = clientRef.current.getSession(serverName);
@@ -3370,9 +3609,22 @@ function useMcp(options) {
           options2
         );
         addLog("info", `Tool "${name}" call successful:`, result);
+        Tel.getInstance().trackUseMcpToolCall({
+          toolName: name,
+          success: true,
+          executionTimeMs: Date.now() - startTime
+        }).catch(() => {
+        });
         return result;
       } catch (err) {
         addLog("error", `Tool "${name}" call failed:`, err);
+        Tel.getInstance().trackUseMcpToolCall({
+          toolName: name,
+          success: false,
+          errorType: err instanceof Error ? err.name : "UnknownError",
+          executionTimeMs: Date.now() - startTime
+        }).catch(() => {
+        });
         throw err;
       }
     },
@@ -3522,9 +3774,20 @@ function useMcp(options) {
         }
         const result = await session.connector.readResource(uri);
         addLog("info", "Resource read successful:", result);
+        Tel.getInstance().trackUseMcpResourceRead({
+          resourceUri: uri,
+          success: true
+        }).catch(() => {
+        });
         return result;
       } catch (err) {
         addLog("error", "Resource read failed:", err);
+        Tel.getInstance().trackUseMcpResourceRead({
+          resourceUri: uri,
+          success: false,
+          errorType: err instanceof Error ? err.name : "UnknownError"
+        }).catch(() => {
+        });
         throw err;
       }
     },
@@ -4654,8 +4917,8 @@ __name(WidgetControls, "WidgetControls");
 var import_react7 = __toESM(require("react"), 1);
 function getBasename() {
   if (typeof window === "undefined") return "/";
-  const path2 = window.location.pathname;
-  const match = path2.match(/^(\/inspector\/api\/dev-widget\/[^/]+)/);
+  const path = window.location.pathname;
+  const match = path.match(/^(\/inspector\/api\/dev-widget\/[^/]+)/);
   if (match) {
     return match[1];
   }