mcp-use 1.10.0-canary.5 → 1.10.0-canary.7

package/dist/index.cjs

@@ -35,9 +35,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 async function getNodeModules() {
   if (typeof process !== "undefined" && process.platform) {
     try {
-      const fs4 = await import("fs");
-      const path4 = await import("path");
-      return { fs: fs4.default, path: path4.default };
+      const fs3 = await import("fs");
+      const path3 = await import("path");
+      return { fs: fs3.default, path: path3.default };
     } catch {
       return { fs: null, path: null };
     }
@@ -1078,11 +1078,13 @@ __export(index_exports, {
   StdioConnector: () => StdioConnector,
   Telemetry: () => Telemetry,
   ThemeProvider: () => ThemeProvider,
+  VERSION: () => VERSION,
   VMCodeExecutor: () => VMCodeExecutor,
   WebSocketConnector: () => WebSocketConnector,
   WidgetControls: () => WidgetControls,
   createOAuthMCPConfig: () => createOAuthMCPConfig,
   createReadableStreamFromGenerator: () => createReadableStreamFromGenerator,
+  getPackageVersion: () => getPackageVersion,
   isVMAvailable: () => isVMAvailable,
   loadConfigFile: () => loadConfigFile,
   logger: () => logger,
@@ -2513,9 +2515,9 @@ var ObservabilityManager = class {
 };
 
 // src/telemetry/telemetry.ts
-var fs2 = __toESM(require("fs"), 1);
+var fs = __toESM(require("fs"), 1);
 var os = __toESM(require("os"), 1);
-var path2 = __toESM(require("path"), 1);
+var path = __toESM(require("path"), 1);
 var import_posthog_node = require("posthog-node");
 
 // src/server/utils/runtime.ts
@@ -2578,23 +2580,265 @@ var MCPAgentExecutionEvent = class extends BaseTelemetryEvent {
     };
   }
 };
+function createServerRunEventData(server, transport) {
+  const toolRegistrations = Array.from(server.registrations.tools.values());
+  const promptRegistrations = Array.from(server.registrations.prompts.values());
+  const resourceRegistrations = Array.from(
+    server.registrations.resources.values()
+  );
+  const templateRegistrations = Array.from(
+    server.registrations.resourceTemplates.values()
+  );
+  const allResources = resourceRegistrations.map((r) => ({
+    name: r.config.name,
+    title: r.config.title ?? null,
+    description: r.config.description ?? null,
+    uri: r.config.uri ?? null,
+    mime_type: r.config.mimeType ?? null
+  }));
+  const appsSdkResources = allResources.filter(
+    (r) => r.mime_type === "text/html+skybridge"
+  );
+  const mcpUiResources = allResources.filter(
+    (r) => r.mime_type === "text/uri-list" || r.mime_type === "text/html"
+  );
+  const mcpAppsResources = allResources.filter(
+    (r) => r.mime_type === "text/html+mcp"
+  );
+  return {
+    transport,
+    toolsNumber: server.registeredTools.length,
+    resourcesNumber: server.registeredResources.length,
+    promptsNumber: server.registeredPrompts.length,
+    auth: !!server.oauthProvider,
+    name: server.config.name,
+    description: server.config.description ?? null,
+    baseUrl: server.serverBaseUrl ?? null,
+    toolNames: server.registeredTools.length > 0 ? server.registeredTools : null,
+    resourceNames: server.registeredResources.length > 0 ? server.registeredResources : null,
+    promptNames: server.registeredPrompts.length > 0 ? server.registeredPrompts : null,
+    tools: toolRegistrations.length > 0 ? toolRegistrations.map((r) => ({
+      name: r.config.name,
+      title: r.config.title ?? null,
+      description: r.config.description ?? null,
+      input_schema: r.config.schema ? JSON.stringify(r.config.schema) : null,
+      output_schema: r.config.outputSchema ? JSON.stringify(r.config.outputSchema) : null
+    })) : null,
+    resources: allResources.length > 0 ? allResources : null,
+    prompts: promptRegistrations.length > 0 ? promptRegistrations.map((r) => ({
+      name: r.config.name,
+      title: r.config.title ?? null,
+      description: r.config.description ?? null,
+      args: r.config.args ? JSON.stringify(r.config.args) : null
+    })) : null,
+    templates: templateRegistrations.length > 0 ? templateRegistrations.map((r) => ({
+      name: r.config.name,
+      title: r.config.title ?? null,
+      description: r.config.description ?? null
+    })) : null,
+    capabilities: {
+      logging: true,
+      resources: { subscribe: true, listChanged: true }
+    },
+    appsSdkResources: appsSdkResources.length > 0 ? appsSdkResources : null,
+    appsSdkResourcesNumber: appsSdkResources.length,
+    mcpUiResources: mcpUiResources.length > 0 ? mcpUiResources : null,
+    mcpUiResourcesNumber: mcpUiResources.length,
+    mcpAppsResources: mcpAppsResources.length > 0 ? mcpAppsResources : null,
+    mcpAppsResourcesNumber: mcpAppsResources.length
+  };
+}
+__name(createServerRunEventData, "createServerRunEventData");
+var ServerRunEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ServerRunEvent");
+  }
+  get name() {
+    return "server_run";
+  }
+  get properties() {
+    return {
+      transport: this.data.transport,
+      tools_number: this.data.toolsNumber,
+      resources_number: this.data.resourcesNumber,
+      prompts_number: this.data.promptsNumber,
+      auth: this.data.auth,
+      name: this.data.name,
+      description: this.data.description ?? null,
+      base_url: this.data.baseUrl ?? null,
+      tool_names: this.data.toolNames ?? null,
+      resource_names: this.data.resourceNames ?? null,
+      prompt_names: this.data.promptNames ?? null,
+      tools: this.data.tools ?? null,
+      resources: this.data.resources ?? null,
+      prompts: this.data.prompts ?? null,
+      templates: this.data.templates ?? null,
+      capabilities: this.data.capabilities ? JSON.stringify(this.data.capabilities) : null,
+      apps_sdk_resources: this.data.appsSdkResources ? JSON.stringify(this.data.appsSdkResources) : null,
+      apps_sdk_resources_number: this.data.appsSdkResourcesNumber ?? 0,
+      mcp_ui_resources: this.data.mcpUiResources ? JSON.stringify(this.data.mcpUiResources) : null,
+      mcp_ui_resources_number: this.data.mcpUiResourcesNumber ?? 0,
+      mcp_apps_resources: this.data.mcpAppsResources ? JSON.stringify(this.data.mcpAppsResources) : null,
+      mcp_apps_resources_number: this.data.mcpAppsResourcesNumber ?? 0
+    };
+  }
+};
+var ServerInitializeEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ServerInitializeEvent");
+  }
+  get name() {
+    return "server_initialize_call";
+  }
+  get properties() {
+    return {
+      protocol_version: this.data.protocolVersion,
+      client_info: JSON.stringify(this.data.clientInfo),
+      client_capabilities: JSON.stringify(this.data.clientCapabilities),
+      session_id: this.data.sessionId ?? null
+    };
+  }
+};
+var ServerToolCallEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ServerToolCallEvent");
+  }
+  get name() {
+    return "server_tool_call";
+  }
+  get properties() {
+    return {
+      tool_name: this.data.toolName,
+      length_input_argument: this.data.lengthInputArgument,
+      success: this.data.success,
+      error_type: this.data.errorType ?? null,
+      execution_time_ms: this.data.executionTimeMs ?? null
+    };
+  }
+};
+var ServerResourceCallEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ServerResourceCallEvent");
+  }
+  get name() {
+    return "server_resource_call";
+  }
+  get properties() {
+    return {
+      name: this.data.name,
+      description: this.data.description,
+      contents: this.data.contents,
+      success: this.data.success,
+      error_type: this.data.errorType ?? null
+    };
+  }
+};
+var ServerPromptCallEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ServerPromptCallEvent");
+  }
+  get name() {
+    return "server_prompt_call";
+  }
+  get properties() {
+    return {
+      name: this.data.name,
+      description: this.data.description,
+      success: this.data.success,
+      error_type: this.data.errorType ?? null
+    };
+  }
+};
+var ServerContextEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ServerContextEvent");
+  }
+  get name() {
+    return `server_context_${this.data.contextType}`;
+  }
+  get properties() {
+    return {
+      context_type: this.data.contextType,
+      notification_type: this.data.notificationType ?? null
+    };
+  }
+};
+var MCPClientInitEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "MCPClientInitEvent");
+  }
+  get name() {
+    return "mcpclient_init";
+  }
+  get properties() {
+    return {
+      code_mode: this.data.codeMode,
+      sandbox: this.data.sandbox,
+      all_callbacks: this.data.allCallbacks,
+      verify: this.data.verify,
+      servers: this.data.servers,
+      num_servers: this.data.numServers
+    };
+  }
+};
+var ConnectorInitEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ConnectorInitEvent");
+  }
+  get name() {
+    return "connector_init";
+  }
+  get properties() {
+    return {
+      connector_type: this.data.connectorType,
+      server_command: this.data.serverCommand ?? null,
+      server_args: this.data.serverArgs ?? null,
+      server_url: this.data.serverUrl ?? null,
+      public_identifier: this.data.publicIdentifier ?? null
+    };
+  }
+};
 
-// src/telemetry/utils.ts
-var fs = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
+// src/version.ts
+var VERSION = "1.10.0-canary.7";
 function getPackageVersion() {
-  try {
-    if (typeof __dirname === "undefined" || typeof fs === "undefined") {
-      return "unknown";
-    }
-    const packagePath = path.join(__dirname, "../../package.json");
-    const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
-    return packageJson.version || "unknown";
-  } catch {
-    return "unknown";
-  }
+  return VERSION;
 }
 __name(getPackageVersion, "getPackageVersion");
+
+// src/telemetry/utils.ts
 function getModelProvider(llm) {
   return llm._llm_type || llm.constructor.name.toLowerCase();
 }
@@ -2627,21 +2871,67 @@ function extractModelInfo(llm) {
 __name(extractModelInfo, "extractModelInfo");
 
 // src/telemetry/telemetry.ts
-function isNodeJSEnvironment2() {
+var USER_ID_STORAGE_KEY = "mcp_use_user_id";
+function detectRuntimeEnvironment() {
   try {
+    if (typeof globalThis.Bun !== "undefined") {
+      return "bun";
+    }
+    if (typeof globalThis.Deno !== "undefined") {
+      return "deno";
+    }
     if (typeof navigator !== "undefined" && navigator.userAgent?.includes("Cloudflare-Workers")) {
-      return false;
+      return "cloudflare-workers";
     }
-    if (typeof globalThis.EdgeRuntime !== "undefined" || typeof globalThis.Deno !== "undefined") {
-      return false;
+    if (typeof globalThis.EdgeRuntime !== "undefined") {
+      return "edge";
     }
-    const hasNodeGlobals = typeof process !== "undefined" && typeof process.platform !== "undefined" && typeof __dirname !== "undefined";
-    const hasNodeModules = typeof fs2 !== "undefined" && typeof os !== "undefined" && typeof fs2.existsSync === "function";
-    return hasNodeGlobals && hasNodeModules;
+    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";
+    }
+    return "unknown";
   } catch {
-    return false;
+    return "unknown";
+  }
+}
+__name(detectRuntimeEnvironment, "detectRuntimeEnvironment");
+function getStorageCapability(env) {
+  switch (env) {
+    case "node":
+    case "bun":
+      return "filesystem";
+    case "browser":
+      try {
+        if (typeof localStorage !== "undefined") {
+          localStorage.setItem("__mcp_use_test__", "1");
+          localStorage.removeItem("__mcp_use_test__");
+          return "localStorage";
+        }
+      } catch {
+      }
+      return "session-only";
+    case "deno":
+      return "session-only";
+    default:
+      return "session-only";
   }
 }
+__name(getStorageCapability, "getStorageCapability");
+var cachedEnvironment = null;
+function getRuntimeEnvironment() {
+  if (cachedEnvironment === null) {
+    cachedEnvironment = detectRuntimeEnvironment();
+  }
+  return cachedEnvironment;
+}
+__name(getRuntimeEnvironment, "getRuntimeEnvironment");
+function isNodeJSEnvironment2() {
+  const env = getRuntimeEnvironment();
+  return env === "node" || env === "bun";
+}
 __name(isNodeJSEnvironment2, "isNodeJSEnvironment");
 var ScarfEventLogger = class {
   static {
@@ -2679,7 +2969,7 @@ function getCacheHome() {
     return "/tmp/mcp_use_cache";
   }
   const envVar = process.env.XDG_CACHE_HOME;
-  if (envVar && path2.isAbsolute(envVar)) {
+  if (envVar && path.isAbsolute(envVar)) {
     return envVar;
   }
   const platform = process.platform;
@@ -2689,11 +2979,11 @@ function getCacheHome() {
     if (appdata) {
       return appdata;
     }
-    return path2.join(homeDir, "AppData", "Local");
+    return path.join(homeDir, "AppData", "Local");
   } else if (platform === "darwin") {
-    return path2.join(homeDir, "Library", "Caches");
+    return path.join(homeDir, "Library", "Caches");
   } else {
-    return path2.join(homeDir, ".cache");
+    return path.join(homeDir, ".cache");
   }
 }
 __name(getCacheHome, "getCacheHome");
@@ -2702,12 +2992,12 @@ var Telemetry = class _Telemetry {
     __name(this, "Telemetry");
   }
   static instance = null;
-  USER_ID_PATH = path2.join(
+  USER_ID_PATH = path.join(
     getCacheHome(),
     "mcp_use_3",
     "telemetry_user_id"
   );
-  VERSION_DOWNLOAD_PATH = path2.join(
+  VERSION_DOWNLOAD_PATH = path.join(
     getCacheHome(),
     "mcp_use",
     "download_version"
@@ -2719,32 +3009,53 @@ var Telemetry = class _Telemetry {
   _currUserId = null;
   _posthogClient = null;
   _scarfClient = null;
-  _source = "typescript";
+  _runtimeEnvironment;
+  _storageCapability;
+  _source;
   constructor() {
-    const isNodeJS = isNodeJSEnvironment2();
+    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;
-    this._source = typeof process !== "undefined" && process.env?.MCP_USE_TELEMETRY_SOURCE || "typescript";
+    const canSupportTelemetry = this._runtimeEnvironment !== "unknown";
+    const isServerlessEnvironment = [
+      "cloudflare-workers",
+      "edge",
+      "deno"
+    ].includes(this._runtimeEnvironment);
     if (telemetryDisabled) {
       this._posthogClient = null;
       this._scarfClient = null;
       logger.debug("Telemetry disabled via environment variable");
-    } else if (!isNodeJS) {
+    } else if (!canSupportTelemetry) {
       this._posthogClient = null;
       this._scarfClient = null;
       logger.debug(
-        "Telemetry disabled - non-Node.js environment detected (e.g., Cloudflare Workers)"
+        `Telemetry disabled - unknown environment: ${this._runtimeEnvironment}`
       );
     } else {
       logger.info(
         "Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable."
       );
-      try {
-        this._posthogClient = new import_posthog_node.PostHog(this.PROJECT_API_KEY, {
-          host: this.HOST,
-          disableGeoip: false
-        });
-      } catch (e) {
-        logger.warn(`Failed to initialize PostHog telemetry: ${e}`);
+      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;
       }
       try {
@@ -2755,6 +3066,18 @@ var Telemetry = class _Telemetry {
       }
     }
   }
+  /**
+   * Get the detected runtime environment
+   */
+  get runtimeEnvironment() {
+    return this._runtimeEnvironment;
+  }
+  /**
+   * Get the storage capability for this environment
+   */
+  get storageCapability() {
+    return this._storageCapability;
+  }
   static getInstance() {
     if (!_Telemetry.instance) {
       _Telemetry.instance = new _Telemetry();
@@ -2776,36 +3099,80 @@ var Telemetry = class _Telemetry {
   getSource() {
     return this._source;
   }
+  /**
+   * 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;
+  }
   get userId() {
     if (this._currUserId) {
       return this._currUserId;
     }
-    if (!isNodeJSEnvironment2()) {
-      this._currUserId = this.UNKNOWN_USER_ID;
-      return this._currUserId;
-    }
     try {
-      const isFirstTime = !fs2.existsSync(this.USER_ID_PATH);
-      if (isFirstTime) {
-        logger.debug(`Creating user ID path: ${this.USER_ID_PATH}`);
-        fs2.mkdirSync(path2.dirname(this.USER_ID_PATH), { recursive: true });
-        const newUserId = generateUUID();
-        fs2.writeFileSync(this.USER_ID_PATH, newUserId);
-        this._currUserId = newUserId;
-        logger.debug(`User ID path created: ${this.USER_ID_PATH}`);
-      } else {
-        this._currUserId = fs2.readFileSync(this.USER_ID_PATH, "utf-8").trim();
+      switch (this._storageCapability) {
+        case "filesystem":
+          this._currUserId = this.getUserIdFromFilesystem();
+          break;
+        case "localStorage":
+          this._currUserId = this.getUserIdFromLocalStorage();
+          break;
+        case "session-only":
+        default:
+          this._currUserId = `session-${generateUUID()}`;
+          logger.debug(
+            `Using session-based user ID (${this._runtimeEnvironment} environment)`
+          );
+          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}`));
       }
-      this.trackPackageDownload({
-        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)
+   */
+  getUserIdFromFilesystem() {
+    const isFirstTime = !fs.existsSync(this.USER_ID_PATH);
+    if (isFirstTime) {
+      logger.debug(`Creating user ID path: ${this.USER_ID_PATH}`);
+      fs.mkdirSync(path.dirname(this.USER_ID_PATH), { recursive: true });
+      const newUserId = generateUUID();
+      fs.writeFileSync(this.USER_ID_PATH, newUserId);
+      logger.debug(`User ID path created: ${this.USER_ID_PATH}`);
+      return newUserId;
+    }
+    return fs.readFileSync(this.USER_ID_PATH, "utf-8").trim();
+  }
+  /**
+   * Get or create user ID from localStorage (Browser)
+   */
+  getUserIdFromLocalStorage() {
+    try {
+      let userId = localStorage.getItem(USER_ID_STORAGE_KEY);
+      if (!userId) {
+        userId = generateUUID();
+        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()}`;
+    }
+  }
   async capture(event) {
+    logger.debug(
+      `CAPTURE: posthog: ${this._posthogClient !== null}, scarf: ${this._scarfClient !== null}`
+    );
     if (!this._posthogClient && !this._scarfClient) {
       return;
     }
@@ -2815,6 +3182,11 @@ var Telemetry = class _Telemetry {
         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({
           distinctId: this.userId,
           event: event.name,
@@ -2832,36 +3204,48 @@ var Telemetry = class _Telemetry {
         properties.event = event.name;
         properties.language = "typescript";
         properties.source = this._source;
+        properties.runtime = this._runtimeEnvironment;
         await this._scarfClient.logEvent(properties);
       } catch (e) {
         logger.debug(`Failed to track Scarf event ${event.name}: ${e}`);
       }
     }
   }
+  /**
+   * Track package download event.
+   * This is a public wrapper that safely accesses userId.
+   */
   async trackPackageDownload(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) {
     if (!this._scarfClient) {
       return;
     }
-    if (!isNodeJSEnvironment2()) {
+    if (this._storageCapability !== "filesystem") {
       return;
     }
     try {
       const currentVersion = getPackageVersion();
       let shouldTrack = false;
       let firstDownload = false;
-      if (!fs2.existsSync(this.VERSION_DOWNLOAD_PATH)) {
+      if (!fs.existsSync(this.VERSION_DOWNLOAD_PATH)) {
         shouldTrack = true;
         firstDownload = true;
-        fs2.mkdirSync(path2.dirname(this.VERSION_DOWNLOAD_PATH), {
+        fs.mkdirSync(path.dirname(this.VERSION_DOWNLOAD_PATH), {
           recursive: true
         });
-        fs2.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
+        fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
       } else {
-        const savedVersion = fs2.readFileSync(this.VERSION_DOWNLOAD_PATH, "utf-8").trim();
+        const savedVersion = fs.readFileSync(this.VERSION_DOWNLOAD_PATH, "utf-8").trim();
         if (currentVersion > savedVersion) {
           shouldTrack = true;
           firstDownload = false;
-          fs2.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
+          fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
         }
       }
       if (shouldTrack) {
@@ -2870,21 +3254,79 @@ var Telemetry = class _Telemetry {
         );
         const eventProperties = { ...properties || {} };
         eventProperties.mcp_use_version = currentVersion;
-        eventProperties.user_id = this.userId;
+        eventProperties.user_id = userId;
         eventProperties.event = "package_download";
         eventProperties.first_download = firstDownload;
         eventProperties.language = "typescript";
         eventProperties.source = this._source;
+        eventProperties.runtime = this._runtimeEnvironment;
         await this._scarfClient.logEvent(eventProperties);
       }
     } catch (e) {
       logger.debug(`Failed to track Scarf package_download event: ${e}`);
     }
   }
+  // ============================================================================
+  // Agent Events
+  // ============================================================================
   async trackAgentExecution(data) {
+    if (!this.isEnabled) return;
     const event = new MCPAgentExecutionEvent(data);
     await this.capture(event);
   }
+  // ============================================================================
+  // Server Events
+  // ============================================================================
+  /**
+   * 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;
+    const data = createServerRunEventData(server, transport);
+    const event = new ServerRunEvent(data);
+    await this.capture(event);
+  }
+  async trackServerInitialize(data) {
+    if (!this.isEnabled) return;
+    const event = new ServerInitializeEvent(data);
+    await this.capture(event);
+  }
+  async trackServerToolCall(data) {
+    if (!this.isEnabled) return;
+    const event = new ServerToolCallEvent(data);
+    await this.capture(event);
+  }
+  async trackServerResourceCall(data) {
+    if (!this.isEnabled) return;
+    const event = new ServerResourceCallEvent(data);
+    await this.capture(event);
+  }
+  async trackServerPromptCall(data) {
+    if (!this.isEnabled) return;
+    const event = new ServerPromptCallEvent(data);
+    await this.capture(event);
+  }
+  async trackServerContext(data) {
+    if (!this.isEnabled) return;
+    const event = new ServerContextEvent(data);
+    await this.capture(event);
+  }
+  // ============================================================================
+  // Client Events
+  // ============================================================================
+  async trackMCPClientInit(data) {
+    if (!this.isEnabled) return;
+    const event = new MCPClientInitEvent(data);
+    await this.capture(event);
+  }
+  async trackConnectorInit(data) {
+    if (!this.isEnabled) return;
+    const event = new ConnectorInitEvent(data);
+    await this.capture(event);
+  }
   flush() {
     if (this._posthogClient) {
       try {
@@ -3246,6 +3688,13 @@ var MCPAgent = class {
   static {
     __name(this, "MCPAgent");
   }
+  /**
+   * Get the mcp-use package version.
+   * Works in all environments (Node.js, browser, Cloudflare Workers, Deno, etc.)
+   */
+  static getPackageVersion() {
+    return getPackageVersion();
+  }
   llm;
   client;
   connectors;
@@ -5667,7 +6116,7 @@ var VMCodeExecutor = class extends BaseCodeExecutor {
 };
 
 // src/connectors/base.ts
-var import_types = require("@modelcontextprotocol/sdk/types.js");
+var import_types = require("@mcp-use/modelcontextprotocol-sdk/types.js");
 init_logging();
 var BaseConnector = class {
   static {
@@ -5688,6 +6137,17 @@ var BaseConnector = class {
       this.rootsCache = [...opts.roots];
     }
   }
+  /**
+   * Track connector initialization event
+   * Should be called by subclasses after successful connection
+   */
+  trackConnectorInit(data) {
+    const connectorType = this.constructor.name;
+    Telemetry.getInstance().trackConnectorInit({
+      connectorType,
+      ...data
+    }).catch((e) => logger.debug(`Failed to track connector init: ${e}`));
+  }
   /**
    * Register a handler for server notifications
    *
@@ -6313,12 +6773,12 @@ var CodeModeConnector = class extends BaseConnector {
 var import_node_fs = require("fs");
 
 // src/connectors/http.ts
-var import_client = require("@modelcontextprotocol/sdk/client/index.js");
-var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+var import_client = require("@mcp-use/modelcontextprotocol-sdk/client/index.js");
+var import_streamableHttp = require("@mcp-use/modelcontextprotocol-sdk/client/streamableHttp.js");
 init_logging();
 
 // src/task_managers/sse.ts
-var import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
+var import_sse = require("@mcp-use/modelcontextprotocol-sdk/client/sse.js");
 init_logging();
 
 // src/task_managers/base.ts
@@ -6531,15 +6991,16 @@ var HttpConnector = class extends BaseConnector {
       let fallbackReason = "Unknown error";
       let is401Error = false;
       if (err instanceof import_streamableHttp.StreamableHTTPError) {
-        is401Error = err.code === 401;
-        if (err.code === 400 && err.message.includes("Missing session ID")) {
+        const streamableErr = err;
+        is401Error = streamableErr.code === 401;
+        if (streamableErr.code === 400 && streamableErr.message.includes("Missing session ID")) {
           fallbackReason = "Server requires session ID (FastMCP compatibility) - using SSE transport";
           logger.warn(`\u26A0\uFE0F  ${fallbackReason}`);
-        } else if (err.code === 404 || err.code === 405) {
-          fallbackReason = `Server returned ${err.code} - server likely doesn't support streamable HTTP`;
+        } else if (streamableErr.code === 404 || streamableErr.code === 405) {
+          fallbackReason = `Server returned ${streamableErr.code} - server likely doesn't support streamable HTTP`;
           logger.debug(fallbackReason);
         } else {
-          fallbackReason = `Server returned ${err.code}: ${err.message}`;
+          fallbackReason = `Server returned ${streamableErr.code}: ${streamableErr.message}`;
           logger.debug(fallbackReason);
         }
       } else if (err instanceof Error) {
@@ -6679,6 +7140,10 @@ var HttpConnector = class extends BaseConnector {
       logger.debug(
         `Successfully connected to MCP implementation via streamable HTTP: ${baseUrl}`
       );
+      this.trackConnectorInit({
+        serverUrl: this.baseUrl,
+        publicIdentifier: `${this.baseUrl} (streamable-http)`
+      });
     } catch (err) {
       await this.cleanupResources();
       throw err;
@@ -6726,6 +7191,10 @@ var HttpConnector = class extends BaseConnector {
       logger.debug(
         `Successfully connected to MCP implementation via HTTP/SSE: ${baseUrl}`
       );
+      this.trackConnectorInit({
+        serverUrl: this.baseUrl,
+        publicIdentifier: `${this.baseUrl} (sse)`
+      });
     } catch (err) {
       await this.cleanupResources();
       throw err;
@@ -6748,11 +7217,11 @@ var HttpConnector = class extends BaseConnector {
 
 // src/connectors/stdio.ts
 var import_node_process = __toESM(require("process"), 1);
-var import_client2 = require("@modelcontextprotocol/sdk/client/index.js");
+var import_client2 = require("@mcp-use/modelcontextprotocol-sdk/client/index.js");
 init_logging();
 
 // src/task_managers/stdio.ts
-var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+var import_stdio = require("@mcp-use/modelcontextprotocol-sdk/client/stdio.js");
 init_logging();
 var StdioConnectionManager = class extends ConnectionManager {
   static {
@@ -6881,6 +7350,11 @@ var StdioConnector = class extends BaseConnector {
       logger.debug(
         `Successfully connected to MCP implementation: ${this.command}`
       );
+      this.trackConnectorInit({
+        serverCommand: this.command,
+        serverArgs: this.args,
+        publicIdentifier: `${this.command} ${this.args.join(" ")}`
+      });
     } catch (err) {
       logger.error(`Failed to connect to MCP implementation: ${err}`);
       await this.cleanupResources();
@@ -7214,6 +7688,13 @@ var MCPClient = class _MCPClient extends BaseMCPClient {
   static {
     __name(this, "MCPClient");
   }
+  /**
+   * Get the mcp-use package version.
+   * Works in all environments (Node.js, browser, Cloudflare Workers, Deno, etc.)
+   */
+  static getPackageVersion() {
+    return getPackageVersion();
+  }
   codeMode = false;
   _codeExecutor = null;
   _customCodeExecutor = null;
@@ -7251,12 +7732,28 @@ var MCPClient = class _MCPClient extends BaseMCPClient {
     if (this.codeMode) {
       this._setupCodeModeConnector();
     }
+    this._trackClientInit();
+  }
+  _trackClientInit() {
+    const servers = Object.keys(this.config.mcpServers ?? {});
+    const hasSamplingCallback = !!this._samplingCallback;
+    const hasElicitationCallback = !!this._elicitationCallback;
+    Telemetry.getInstance().trackMCPClientInit({
+      codeMode: this.codeMode,
+      sandbox: false,
+      // Sandbox not supported in TS yet
+      allCallbacks: hasSamplingCallback && hasElicitationCallback,
+      verify: false,
+      // No verify option in TS client
+      servers,
+      numServers: servers.length
+    }).catch((e) => logger.debug(`Failed to track MCPClient init: ${e}`));
   }
   static fromDict(cfg, options) {
     return new _MCPClient(cfg, options);
   }
-  static fromConfigFile(path4, options) {
-    return new _MCPClient(loadConfigFile(path4), options);
+  static fromConfigFile(path3, options) {
+    return new _MCPClient(loadConfigFile(path3), options);
   }
   /**
    * Save configuration to a file (Node.js only)
@@ -8108,7 +8605,7 @@ var BrowserOAuthClientProvider = class {
 };
 
 // src/auth/callback.ts
-var import_auth = require("@modelcontextprotocol/sdk/client/auth.js");
+var import_auth = require("@mcp-use/modelcontextprotocol-sdk/client/auth.js");
 async function onMcpAuthorization() {
   const queryParams = new URLSearchParams(window.location.search);
   const code = queryParams.get("code");
@@ -8251,6 +8748,13 @@ var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
   static {
     __name(this, "BrowserMCPClient");
   }
+  /**
+   * Get the mcp-use package version.
+   * Works in all environments (Node.js, browser, Cloudflare Workers, Deno, etc.)
+   */
+  static getPackageVersion() {
+    return getPackageVersion();
+  }
   constructor(config) {
     super(config);
   }
@@ -8567,7 +9071,7 @@ function useMcp(options) {
               "Authentication required. OAuth provider available."
             );
             try {
-              const { auth: auth2 } = await import("@modelcontextprotocol/sdk/client/auth.js");
+              const { auth: auth2 } = await import("@mcp-use/modelcontextprotocol-sdk/client/auth.js");
               const baseUrl = new URL(url).origin;
               auth2(authProviderRef.current, { serverUrl: baseUrl }).catch(
                 () => {
@@ -8735,7 +9239,7 @@ function useMcp(options) {
         });
         authProviderRef.current = freshAuthProvider;
         addLog("info", "Triggering fresh OAuth authorization...");
-        const { auth: auth2 } = await import("@modelcontextprotocol/sdk/client/auth.js");
+        const { auth: auth2 } = await import("@mcp-use/modelcontextprotocol-sdk/client/auth.js");
         const baseUrl = new URL(url).origin;
         auth2(freshAuthProvider, {
           serverUrl: baseUrl
@@ -8743,7 +9247,7 @@ function useMcp(options) {
           addLog(
             "info",
             "OAuth flow initiated:",
-            err?.message || "Redirecting..."
+            err instanceof Error ? err.message : "Redirecting..."
           );
         });
       } catch (authError) {
@@ -9797,8 +10301,8 @@ __name(WidgetControls, "WidgetControls");
 var import_react7 = __toESM(require("react"), 1);
 function getBasename() {
   if (typeof window === "undefined") return "/";
-  const path4 = window.location.pathname;
-  const match = path4.match(/^(\/inspector\/api\/dev-widget\/[^/]+)/);
+  const path3 = window.location.pathname;
+  const match = path3.match(/^(\/inspector\/api\/dev-widget\/[^/]+)/);
   if (match) {
     return match[1];
   }