mcp-use 1.9.1-canary.1 → 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,
@@ -75,8 +80,8 @@ function sanitizeParam([k, v]) {
 __name(sanitizeParam, "sanitizeParam");
 
 // 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");
 
 // src/logging.ts
 async function getNodeModules() {
@@ -350,7 +355,7 @@ if (isNodeJSEnvironment()) {
 var logger = Logger.get();
 
 // 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");
 
 // src/task_managers/base.ts
 var ConnectionManager = class {
@@ -513,7 +518,1006 @@ var SseConnectionManager = class extends ConnectionManager {
 };
 
 // src/connectors/base.ts
-var import_types = require("@modelcontextprotocol/sdk/types.js");
+var import_types = require("@mcp-use/modelcontextprotocol-sdk/types.js");
+
+// src/telemetry/events.ts
+var BaseTelemetryEvent = class {
+  static {
+    __name(this, "BaseTelemetryEvent");
+  }
+};
+var MCPAgentExecutionEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "MCPAgentExecutionEvent");
+  }
+  get name() {
+    return "mcp_agent_execution";
+  }
+  get properties() {
+    return {
+      // Core execution info
+      execution_method: this.data.executionMethod,
+      query: this.data.query,
+      query_length: this.data.query.length,
+      success: this.data.success,
+      // Agent configuration
+      model_provider: this.data.modelProvider,
+      model_name: this.data.modelName,
+      server_count: this.data.serverCount,
+      server_identifiers: this.data.serverIdentifiers,
+      total_tools_available: this.data.totalToolsAvailable,
+      tools_available_names: this.data.toolsAvailableNames,
+      max_steps_configured: this.data.maxStepsConfigured,
+      memory_enabled: this.data.memoryEnabled,
+      use_server_manager: this.data.useServerManager,
+      // Execution parameters (always include, even if null)
+      max_steps_used: this.data.maxStepsUsed,
+      manage_connector: this.data.manageConnector,
+      external_history_used: this.data.externalHistoryUsed,
+      // Execution results (always include, even if null)
+      steps_taken: this.data.stepsTaken ?? null,
+      tools_used_count: this.data.toolsUsedCount ?? null,
+      tools_used_names: this.data.toolsUsedNames ?? null,
+      response: this.data.response ?? null,
+      response_length: this.data.response ? this.data.response.length : null,
+      execution_time_ms: this.data.executionTimeMs ?? null,
+      error_type: this.data.errorType ?? null,
+      conversation_history_length: this.data.conversationHistoryLength ?? null
+    };
+  }
+};
+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,
+      is_browser: this.data.isBrowser
+    };
+  }
+};
+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
+    };
+  }
+};
+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.11";
+function getPackageVersion() {
+  return VERSION;
+}
+__name(getPackageVersion, "getPackageVersion");
+
+// src/telemetry/telemetry.ts
+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 "cloudflare-workers";
+    }
+    if (typeof globalThis.EdgeRuntime !== "undefined") {
+      return "edge";
+    }
+    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";
+  }
+}
+__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");
+var ScarfEventLogger = class {
+  static {
+    __name(this, "ScarfEventLogger");
+  }
+  endpoint;
+  timeout;
+  constructor(endpoint, timeout = 3e3) {
+    this.endpoint = endpoint;
+    this.timeout = timeout;
+  }
+  async logEvent(properties) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(properties),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+    } catch (error) {
+      logger.debug(`Failed to send Scarf event: ${error}`);
+    }
+  }
+};
+var Telemetry = class _Telemetry {
+  static {
+    __name(this, "Telemetry");
+  }
+  static instance = null;
+  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;
+  _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 = this._checkTelemetryDisabled();
+    const canSupportTelemetry = this._runtimeEnvironment !== "unknown";
+    if (telemetryDisabled) {
+      this._posthogNodeClient = null;
+      this._posthogBrowserClient = null;
+      this._scarfClient = null;
+      logger.debug("Telemetry disabled via environment/localStorage");
+    } else if (!canSupportTelemetry) {
+      this._posthogNodeClient = null;
+      this._posthogBrowserClient = null;
+      this._scarfClient = null;
+      logger.debug(
+        `Telemetry disabled - unknown environment: ${this._runtimeEnvironment}`
+      );
+    } else {
+      logger.info(
+        "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}`);
+        this._scarfClient = null;
+      }
+    }
+  }
+  _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
+   */
+  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();
+    }
+    return _Telemetry.instance;
+  }
+  /**
+   * Set the source identifier for telemetry events.
+   * This allows tracking usage from different applications.
+   * @param source - The source identifier (e.g., "my-app", "cli", "vs-code-extension")
+   */
+  setSource(source) {
+    this._source = source;
+    logger.debug(`Telemetry source set to: ${source}`);
+  }
+  /**
+   * Get the current source identifier.
+   */
+  getSource() {
+    return this._source;
+  }
+  /**
+   * Check if telemetry is enabled.
+   */
+  get isEnabled() {
+    return this._posthogNodeClient !== null || this._posthogBrowserClient !== null || this._scarfClient !== null;
+  }
+  get userId() {
+    if (this._currUserId) {
+      return this._currUserId;
+    }
+    try {
+      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}`));
+      }
+    } 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 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;
+    }
+    return fs.readFileSync(this._userIdPath, "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()}`;
+    }
+  }
+  _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) {
+    if (this._posthogLoading) {
+      await this._posthogLoading;
+    }
+    if (!this._posthogNodeClient && !this._posthogBrowserClient && !this._scarfClient) {
+      return;
+    }
+    const properties = { ...event.properties };
+    properties.mcp_use_version = getPackageVersion();
+    properties.language = "typescript";
+    properties.source = this._source;
+    properties.runtime = this._runtimeEnvironment;
+    if (this._posthogNodeClient) {
+      try {
+        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 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 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);
+  }
+  /**
+   * Internal method to track package download with explicit userId.
+   */
+  async _trackPackageDownloadInternal(userId, properties) {
+    if (!this._scarfClient) {
+      return;
+    }
+    if (this._storageCapability !== "filesystem") {
+      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._versionDownloadPath)) {
+        shouldTrack = true;
+        firstDownload = true;
+        fs.mkdirSync(path.dirname(this._versionDownloadPath), {
+          recursive: true
+        });
+        fs.writeFileSync(this._versionDownloadPath, currentVersion);
+      } else {
+        const savedVersion = fs.readFileSync(this._versionDownloadPath, "utf-8").trim();
+        if (currentVersion > savedVersion) {
+          shouldTrack = true;
+          firstDownload = false;
+          fs.writeFileSync(this._versionDownloadPath, currentVersion);
+        }
+      }
+      if (shouldTrack) {
+        logger.debug(
+          `Tracking package download event with properties: ${JSON.stringify(properties)}`
+        );
+        const eventProperties = { ...properties || {} };
+        eventProperties.mcp_use_version = currentVersion;
+        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.
+   */
+  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);
+  }
+  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._posthogNodeClient) {
+      try {
+        this._posthogNodeClient.flush();
+        logger.debug("PostHog client telemetry queue flushed");
+      } catch (e) {
+        logger.debug(`Failed to flush PostHog client: ${e}`);
+      }
+    }
+  }
+  /**
+   * Shutdown the telemetry client (Node.js only)
+   */
+  shutdown() {
+    if (this._posthogNodeClient) {
+      try {
+        this._posthogNodeClient.shutdown();
+        logger.debug("PostHog client shutdown successfully");
+      } catch (e) {
+        logger.debug(`Error shutting down PostHog client: ${e}`);
+      }
+    }
+  }
+};
+var Tel = Telemetry;
+function setTelemetrySource(source) {
+  Tel.getInstance().setSource(source);
+}
+__name(setTelemetrySource, "setTelemetrySource");
+
+// src/connectors/base.ts
 var BaseConnector = class {
   static {
     __name(this, "BaseConnector");
@@ -533,6 +1537,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
    *
@@ -741,7 +1756,7 @@ var BaseConnector = class {
     }
     logger.debug("Caching server capabilities & tools");
     const capabilities = this.client.getServerCapabilities();
-    this.capabilitiesCache = capabilities;
+    this.capabilitiesCache = capabilities || null;
     const serverInfo = this.client.getServerVersion();
     this.serverInfoCache = serverInfo || null;
     const listToolsRes = await this.client.listTools(
@@ -763,7 +1778,7 @@ var BaseConnector = class {
   }
   /** Expose cached server capabilities. */
   get serverCapabilities() {
-    return this.capabilitiesCache;
+    return this.capabilitiesCache || {};
   }
   /** Expose cached server info. */
   get serverInfo() {
@@ -830,7 +1845,8 @@ var BaseConnector = class {
       } while (cursor);
       return { resources: allResources };
     } catch (err) {
-      if (err.code === -32601) {
+      const error = err;
+      if (error.code === -32601) {
         logger.debug("Server advertised resources but method not found");
         return { resources: [] };
       }
@@ -897,7 +1913,8 @@ var BaseConnector = class {
       logger.debug("Listing prompts");
       return await this.client.listPrompts();
     } catch (err) {
-      if (err.code === -32601) {
+      const error = err;
+      if (error.code === -32601) {
         logger.debug("Server advertised prompts but method not found");
         return { prompts: [] };
       }
@@ -1008,15 +2025,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) {
@@ -1156,6 +2174,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;
@@ -1203,6 +2225,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;
@@ -1223,13 +2249,6 @@ var HttpConnector = class extends BaseConnector {
   }
 };
 
-// src/server/utils/runtime.ts
-var isDeno = typeof globalThis.Deno !== "undefined";
-function generateUUID() {
-  return globalThis.crypto.randomUUID();
-}
-__name(generateUUID, "generateUUID");
-
 // src/task_managers/websocket.ts
 var import_ws = __toESM(require("ws"), 1);
 var WebSocketConnectionManager = class extends ConnectionManager {
@@ -1574,6 +2593,190 @@ var MCPSession = class {
   getRoots() {
     return this.connector.getRoots();
   }
+  /**
+   * Get the cached list of tools from the server.
+   *
+   * @returns Array of available tools
+   *
+   * @example
+   * ```typescript
+   * const tools = session.tools;
+   * console.log(`Available tools: ${tools.map(t => t.name).join(", ")}`);
+   * ```
+   */
+  get tools() {
+    return this.connector.tools;
+  }
+  /**
+   * Get the server capabilities advertised during initialization.
+   *
+   * @returns Server capabilities object
+   */
+  get serverCapabilities() {
+    return this.connector.serverCapabilities;
+  }
+  /**
+   * Get the server information (name and version).
+   *
+   * @returns Server info object or null if not available
+   */
+  get serverInfo() {
+    return this.connector.serverInfo;
+  }
+  /**
+   * Call a tool on the server.
+   *
+   * @param name - Name of the tool to call
+   * @param args - Arguments to pass to the tool
+   * @param options - Optional request options (timeout, progress handlers, etc.)
+   * @returns Result from the tool execution
+   *
+   * @example
+   * ```typescript
+   * const result = await session.callTool("add", { a: 5, b: 3 });
+   * console.log(`Result: ${result.content[0].text}`);
+   * ```
+   */
+  async callTool(name, args, options) {
+    return this.connector.callTool(name, args, options);
+  }
+  /**
+   * List resources from the server with optional pagination.
+   *
+   * @param cursor - Optional cursor for pagination
+   * @param options - Request options
+   * @returns Resource list with optional nextCursor for pagination
+   *
+   * @example
+   * ```typescript
+   * const result = await session.listResources();
+   * console.log(`Found ${result.resources.length} resources`);
+   * ```
+   */
+  async listResources(cursor, options) {
+    return this.connector.listResources(cursor, options);
+  }
+  /**
+   * List all resources from the server, automatically handling pagination.
+   *
+   * @param options - Request options
+   * @returns Complete list of all resources
+   *
+   * @example
+   * ```typescript
+   * const result = await session.listAllResources();
+   * console.log(`Total resources: ${result.resources.length}`);
+   * ```
+   */
+  async listAllResources(options) {
+    return this.connector.listAllResources(options);
+  }
+  /**
+   * List resource templates from the server.
+   *
+   * @param options - Request options
+   * @returns List of available resource templates
+   *
+   * @example
+   * ```typescript
+   * const result = await session.listResourceTemplates();
+   * console.log(`Available templates: ${result.resourceTemplates.length}`);
+   * ```
+   */
+  async listResourceTemplates(options) {
+    return this.connector.listResourceTemplates(options);
+  }
+  /**
+   * Read a resource by URI.
+   *
+   * @param uri - URI of the resource to read
+   * @param options - Request options
+   * @returns Resource content
+   *
+   * @example
+   * ```typescript
+   * const resource = await session.readResource("file:///path/to/file.txt");
+   * console.log(resource.contents);
+   * ```
+   */
+  async readResource(uri, options) {
+    return this.connector.readResource(uri, options);
+  }
+  /**
+   * Subscribe to resource updates.
+   *
+   * @param uri - URI of the resource to subscribe to
+   * @param options - Request options
+   *
+   * @example
+   * ```typescript
+   * await session.subscribeToResource("file:///path/to/file.txt");
+   * // Now you'll receive notifications when this resource changes
+   * ```
+   */
+  async subscribeToResource(uri, options) {
+    return this.connector.subscribeToResource(uri, options);
+  }
+  /**
+   * Unsubscribe from resource updates.
+   *
+   * @param uri - URI of the resource to unsubscribe from
+   * @param options - Request options
+   *
+   * @example
+   * ```typescript
+   * await session.unsubscribeFromResource("file:///path/to/file.txt");
+   * ```
+   */
+  async unsubscribeFromResource(uri, options) {
+    return this.connector.unsubscribeFromResource(uri, options);
+  }
+  /**
+   * List available prompts from the server.
+   *
+   * @returns List of available prompts
+   *
+   * @example
+   * ```typescript
+   * const result = await session.listPrompts();
+   * console.log(`Available prompts: ${result.prompts.length}`);
+   * ```
+   */
+  async listPrompts() {
+    return this.connector.listPrompts();
+  }
+  /**
+   * Get a specific prompt with arguments.
+   *
+   * @param name - Name of the prompt to get
+   * @param args - Arguments for the prompt
+   * @returns Prompt result
+   *
+   * @example
+   * ```typescript
+   * const prompt = await session.getPrompt("greeting", { name: "Alice" });
+   * console.log(prompt.messages);
+   * ```
+   */
+  async getPrompt(name, args) {
+    return this.connector.getPrompt(name, args);
+  }
+  /**
+   * Send a raw request through the client.
+   *
+   * @param method - MCP method name
+   * @param params - Request parameters
+   * @param options - Request options
+   * @returns Response from the server
+   *
+   * @example
+   * ```typescript
+   * const result = await session.request("custom/method", { key: "value" });
+   * ```
+   */
+  async request(method, params = null, options) {
+    return this.connector.request(method, params, options);
+  }
 };
 
 // src/client/base.ts
@@ -1595,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() {
@@ -1698,8 +2903,34 @@ 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);
+    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);
@@ -2110,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) {
@@ -2220,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 || []);
@@ -2237,15 +3489,16 @@ function useMcp(options) {
         }
         return "success";
       } catch (err) {
-        const errorMessage = err?.message || String(err);
-        if (err.code === 401 || errorMessage.includes("401") || errorMessage.includes("Unauthorized")) {
+        const error2 = err;
+        const errorMessage = error2?.message || String(err);
+        if (error2.code === 401 || errorMessage.includes("401") || errorMessage.includes("Unauthorized")) {
           if (authProviderRef.current) {
             addLog(
               "info",
               "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(
                 () => {
@@ -2286,7 +3539,10 @@ function useMcp(options) {
           );
           return "failed";
         }
-        failConnection(errorMessage, err);
+        failConnection(
+          errorMessage,
+          error2 instanceof Error ? error2 : new Error(String(error2))
+        );
         return "failed";
       }
     }, "tryConnectWithTransport");
@@ -2340,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);
@@ -2352,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;
       }
     },
@@ -2410,7 +3680,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
@@ -2418,7 +3688,7 @@ function useMcp(options) {
           addLog(
             "info",
             "OAuth flow initiated:",
-            err?.message || "Redirecting..."
+            err instanceof Error ? err.message : "Redirecting..."
           );
         });
       } catch (authError) {
@@ -2504,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;
       }
     },
@@ -2693,7 +3974,7 @@ function useMcp(options) {
 __name(useMcp, "useMcp");
 
 // 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");
@@ -2801,16 +4082,44 @@ async function onMcpAuthorization() {
       );
     }
     try {
-      document.body.innerHTML = `
-            <div style="font-family: sans-serif; padding: 20px;">
-            <h1>Authentication Error</h1>
-            <p style="color: red; background-color: #ffebeb; border: 1px solid red; padding: 10px; border-radius: 4px;">
-                ${errorMessage}
-            </p>
-            <p>You can close this window or <a href="#" onclick="window.close(); return false;">click here to close</a>.</p>
-            <pre style="font-size: 0.8em; color: #555; margin-top: 20px; white-space: pre-wrap;">${err instanceof Error ? err.stack : ""}</pre>
-            </div>
-        `;
+      document.body.innerHTML = "";
+      const container = document.createElement("div");
+      container.style.fontFamily = "sans-serif";
+      container.style.padding = "20px";
+      const heading = document.createElement("h1");
+      heading.textContent = "Authentication Error";
+      container.appendChild(heading);
+      const errorPara = document.createElement("p");
+      errorPara.style.color = "red";
+      errorPara.style.backgroundColor = "#ffebeb";
+      errorPara.style.border = "1px solid red";
+      errorPara.style.padding = "10px";
+      errorPara.style.borderRadius = "4px";
+      errorPara.textContent = errorMessage;
+      container.appendChild(errorPara);
+      const closePara = document.createElement("p");
+      closePara.textContent = "You can close this window or ";
+      const closeLink = document.createElement("a");
+      closeLink.href = "#";
+      closeLink.textContent = "click here to close";
+      closeLink.onclick = (e) => {
+        e.preventDefault();
+        window.close();
+        return false;
+      };
+      closePara.appendChild(closeLink);
+      closePara.appendChild(document.createTextNode("."));
+      container.appendChild(closePara);
+      if (err instanceof Error && err.stack) {
+        const stackPre = document.createElement("pre");
+        stackPre.style.fontSize = "0.8em";
+        stackPre.style.color = "#555";
+        stackPre.style.marginTop = "20px";
+        stackPre.style.whiteSpace = "pre-wrap";
+        stackPre.textContent = err.stack;
+        container.appendChild(stackPre);
+      }
+      document.body.appendChild(container);
     } catch (displayError) {
       console.error(
         `${logPrefix} Could not display error in callback window:`,
@@ -3290,7 +4599,8 @@ function WidgetControls({
       const result = await callTool(toolName, args);
       setActionResult(`Success: ${JSON.stringify(result, null, 2)}`);
     } catch (error) {
-      setActionResult(`Error: ${error.message}`);
+      const err = error;
+      setActionResult(`Error: ${err.message}`);
     }
   }, "handleCallTool");
   const handleSendFollowUpMessage = /* @__PURE__ */ __name(async () => {
@@ -3299,7 +4609,8 @@ function WidgetControls({
       await sendFollowUpMessage(followUpMessage);
       setActionResult("Follow-up message sent successfully");
     } catch (error) {
-      setActionResult(`Error: ${error.message}`);
+      const err = error;
+      setActionResult(`Error: ${err.message}`);
     }
   }, "handleSendFollowUpMessage");
   const handleOpenExternal = /* @__PURE__ */ __name(() => {
@@ -3307,7 +4618,8 @@ function WidgetControls({
       openExternal(externalUrl);
       setActionResult(`Opened external link: ${externalUrl}`);
     } catch (error) {
-      setActionResult(`Error: ${error.message}`);
+      const err = error;
+      setActionResult(`Error: ${err.message}`);
     }
   }, "handleOpenExternal");
   const handleRequestDisplayMode = /* @__PURE__ */ __name(async (mode) => {
@@ -3316,7 +4628,8 @@ function WidgetControls({
       const result = await requestDisplayMode(mode);
       setActionResult(`Display mode granted: ${result.mode}`);
     } catch (error) {
-      setActionResult(`Error: ${error.message}`);
+      const err = error;
+      setActionResult(`Error: ${err.message}`);
     }
   }, "handleRequestDisplayMode");
   const handleSetState = /* @__PURE__ */ __name(async () => {
@@ -3326,7 +4639,8 @@ function WidgetControls({
       await setState(newState);
       setActionResult(`State updated: ${JSON.stringify(newState, null, 2)}`);
     } catch (error) {
-      setActionResult(`Error: ${error.message}`);
+      const err = error;
+      setActionResult(`Error: ${err.message}`);
     }
   }, "handleSetState");
   const handleFullscreen = /* @__PURE__ */ __name(async () => {