mcp-use 1.10.0-canary.8 → 1.10.0

package/dist/src/server/index.cjs

@@ -31,374 +31,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/server/utils/runtime.ts
-function getEnv(key) {
-  if (isDeno) {
-    return globalThis.Deno.env.get(key);
-  }
-  return process.env[key];
-}
-function getCwd() {
-  if (isDeno) {
-    return globalThis.Deno.cwd();
-  }
-  return process.cwd();
-}
-function generateUUID() {
-  return globalThis.crypto.randomUUID();
-}
-var isDeno, fsHelpers, pathHelpers;
-var init_runtime = __esm({
-  "src/server/utils/runtime.ts"() {
-    "use strict";
-    isDeno = typeof globalThis.Deno !== "undefined";
-    __name(getEnv, "getEnv");
-    __name(getCwd, "getCwd");
-    fsHelpers = {
-      async readFileSync(path2, encoding = "utf8") {
-        if (isDeno) {
-          return await globalThis.Deno.readTextFile(path2);
-        }
-        const { readFileSync: readFileSync2 } = await import("fs");
-        const result = readFileSync2(path2, encoding);
-        return typeof result === "string" ? result : result.toString(encoding);
-      },
-      async readFile(path2) {
-        if (isDeno) {
-          const data = await globalThis.Deno.readFile(path2);
-          return data.buffer;
-        }
-        const { readFileSync: readFileSync2 } = await import("fs");
-        const buffer = readFileSync2(path2);
-        return buffer.buffer.slice(
-          buffer.byteOffset,
-          buffer.byteOffset + buffer.byteLength
-        );
-      },
-      async existsSync(path2) {
-        if (isDeno) {
-          try {
-            await globalThis.Deno.stat(path2);
-            return true;
-          } catch {
-            return false;
-          }
-        }
-        const { existsSync: existsSync2 } = await import("fs");
-        return existsSync2(path2);
-      },
-      async readdirSync(path2) {
-        if (isDeno) {
-          const entries = [];
-          for await (const entry of globalThis.Deno.readDir(path2)) {
-            entries.push(entry.name);
-          }
-          return entries;
-        }
-        const { readdirSync } = await import("fs");
-        return readdirSync(path2);
-      }
-    };
-    pathHelpers = {
-      join(...paths) {
-        if (isDeno) {
-          return paths.join("/").replace(/\/+/g, "/");
-        }
-        return paths.join("/").replace(/\/+/g, "/");
-      },
-      relative(from, to) {
-        const fromParts = from.split("/").filter((p) => p);
-        const toParts = to.split("/").filter((p) => p);
-        let i = 0;
-        while (i < fromParts.length && i < toParts.length && fromParts[i] === toParts[i]) {
-          i++;
-        }
-        const upCount = fromParts.length - i;
-        const relativeParts = [...Array(upCount).fill(".."), ...toParts.slice(i)];
-        return relativeParts.join("/");
-      }
-    };
-    __name(generateUUID, "generateUUID");
-  }
-});
-
-// src/logging.ts
-async function getNodeModules() {
-  if (typeof process !== "undefined" && process.platform) {
-    try {
-      const fs2 = await import("fs");
-      const path2 = await import("path");
-      return { fs: fs2.default, path: path2.default };
-    } catch {
-      return { fs: null, path: null };
-    }
-  }
-  return { fs: null, path: null };
-}
-function loadWinstonSync() {
-  if (typeof require !== "undefined") {
-    try {
-      winston = require("winston");
-    } catch {
-    }
-  }
-}
-async function getWinston() {
-  if (!winston) {
-    winston = await import("winston");
-  }
-  return winston;
-}
-function isNodeJSEnvironment() {
-  try {
-    if (typeof navigator !== "undefined" && navigator.userAgent?.includes("Cloudflare-Workers")) {
-      return false;
-    }
-    if (typeof globalThis.EdgeRuntime !== "undefined" || typeof globalThis.Deno !== "undefined") {
-      return false;
-    }
-    const hasNodeGlobals = typeof process !== "undefined" && typeof process.platform !== "undefined" && typeof __dirname !== "undefined";
-    return hasNodeGlobals;
-  } catch {
-    return false;
-  }
-}
-function resolveLevel(env) {
-  const envValue = typeof process !== "undefined" && process.env ? env : void 0;
-  switch (envValue?.trim()) {
-    case "2":
-      return "debug";
-    case "1":
-      return "info";
-    default:
-      return "info";
-  }
-}
-var winston, DEFAULT_LOGGER_NAME, SimpleConsoleLogger, Logger, logger;
-var init_logging = __esm({
-  "src/logging.ts"() {
-    "use strict";
-    __name(getNodeModules, "getNodeModules");
-    winston = null;
-    __name(loadWinstonSync, "loadWinstonSync");
-    __name(getWinston, "getWinston");
-    DEFAULT_LOGGER_NAME = "mcp-use";
-    __name(isNodeJSEnvironment, "isNodeJSEnvironment");
-    SimpleConsoleLogger = class {
-      static {
-        __name(this, "SimpleConsoleLogger");
-      }
-      _level;
-      name;
-      constructor(name = DEFAULT_LOGGER_NAME, level = "info") {
-        this.name = name;
-        this._level = level;
-      }
-      shouldLog(level) {
-        const levels = [
-          "error",
-          "warn",
-          "info",
-          "http",
-          "verbose",
-          "debug",
-          "silly"
-        ];
-        const currentIndex = levels.indexOf(this._level);
-        const messageIndex = levels.indexOf(level);
-        return messageIndex <= currentIndex;
-      }
-      formatMessage(level, message) {
-        const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
-        return `${timestamp} [${this.name}] ${level}: ${message}`;
-      }
-      error(message) {
-        if (this.shouldLog("error")) {
-          console.error(this.formatMessage("error", message));
-        }
-      }
-      warn(message) {
-        if (this.shouldLog("warn")) {
-          console.warn(this.formatMessage("warn", message));
-        }
-      }
-      info(message) {
-        if (this.shouldLog("info")) {
-          console.info(this.formatMessage("info", message));
-        }
-      }
-      debug(message) {
-        if (this.shouldLog("debug")) {
-          console.debug(this.formatMessage("debug", message));
-        }
-      }
-      http(message) {
-        if (this.shouldLog("http")) {
-          console.log(this.formatMessage("http", message));
-        }
-      }
-      verbose(message) {
-        if (this.shouldLog("verbose")) {
-          console.log(this.formatMessage("verbose", message));
-        }
-      }
-      silly(message) {
-        if (this.shouldLog("silly")) {
-          console.log(this.formatMessage("silly", message));
-        }
-      }
-      // Make it compatible with Winston interface
-      get level() {
-        return this._level;
-      }
-      set level(newLevel) {
-        this._level = newLevel;
-      }
-    };
-    __name(resolveLevel, "resolveLevel");
-    Logger = class {
-      static {
-        __name(this, "Logger");
-      }
-      static instances = {};
-      static simpleInstances = {};
-      static currentFormat = "minimal";
-      static get(name = DEFAULT_LOGGER_NAME) {
-        if (!isNodeJSEnvironment()) {
-          if (!this.simpleInstances[name]) {
-            const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || void 0;
-            this.simpleInstances[name] = new SimpleConsoleLogger(
-              name,
-              resolveLevel(debugEnv)
-            );
-          }
-          return this.simpleInstances[name];
-        }
-        if (!this.instances[name]) {
-          if (!winston) {
-            throw new Error("Winston not loaded - call Logger.configure() first");
-          }
-          const { createLogger, format } = winston;
-          const { combine, timestamp, label, colorize, splat } = format;
-          this.instances[name] = createLogger({
-            level: resolveLevel(process.env.DEBUG),
-            format: combine(
-              colorize(),
-              splat(),
-              label({ label: name }),
-              timestamp({ format: "HH:mm:ss" }),
-              this.getFormatter()
-            ),
-            transports: []
-          });
-        }
-        return this.instances[name];
-      }
-      static getFormatter() {
-        if (!winston) {
-          throw new Error("Winston not loaded");
-        }
-        const { format } = winston;
-        const { printf } = format;
-        const minimalFormatter = printf(({ level, message, label, timestamp }) => {
-          return `${timestamp} [${label}] ${level}: ${message}`;
-        });
-        const detailedFormatter = printf(({ level, message, label, timestamp }) => {
-          return `${timestamp} [${label}] ${level.toUpperCase()}: ${message}`;
-        });
-        const emojiFormatter = printf(({ level, message, label, timestamp }) => {
-          return `${timestamp} [${label}] ${level.toUpperCase()}: ${message}`;
-        });
-        switch (this.currentFormat) {
-          case "minimal":
-            return minimalFormatter;
-          case "detailed":
-            return detailedFormatter;
-          case "emoji":
-            return emojiFormatter;
-          default:
-            return minimalFormatter;
-        }
-      }
-      static async configure(options = {}) {
-        const { level, console: console2 = true, file, format = "minimal" } = options;
-        const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || void 0;
-        const resolvedLevel = level ?? resolveLevel(debugEnv);
-        this.currentFormat = format;
-        if (!isNodeJSEnvironment()) {
-          Object.values(this.simpleInstances).forEach((logger2) => {
-            logger2.level = resolvedLevel;
-          });
-          return;
-        }
-        await getWinston();
-        if (!winston) {
-          throw new Error("Failed to load winston");
-        }
-        const root = this.get();
-        root.level = resolvedLevel;
-        const winstonRoot = root;
-        winstonRoot.clear();
-        if (console2) {
-          winstonRoot.add(new winston.transports.Console());
-        }
-        if (file) {
-          const { fs: nodeFs, path: nodePath } = await getNodeModules();
-          if (nodeFs && nodePath) {
-            const dir = nodePath.dirname(nodePath.resolve(file));
-            if (!nodeFs.existsSync(dir)) {
-              nodeFs.mkdirSync(dir, { recursive: true });
-            }
-            winstonRoot.add(new winston.transports.File({ filename: file }));
-          }
-        }
-        const { format: winstonFormat } = winston;
-        const { combine, timestamp, label, colorize, splat } = winstonFormat;
-        Object.values(this.instances).forEach((logger2) => {
-          if (logger2 && "format" in logger2) {
-            logger2.level = resolvedLevel;
-            logger2.format = combine(
-              colorize(),
-              splat(),
-              label({ label: DEFAULT_LOGGER_NAME }),
-              timestamp({ format: "HH:mm:ss" }),
-              this.getFormatter()
-            );
-          }
-        });
-      }
-      static setDebug(enabled) {
-        let level;
-        if (enabled === 2 || enabled === true) level = "debug";
-        else if (enabled === 1) level = "info";
-        else level = "info";
-        Object.values(this.simpleInstances).forEach((logger2) => {
-          logger2.level = level;
-        });
-        Object.values(this.instances).forEach((logger2) => {
-          if (logger2) {
-            logger2.level = level;
-          }
-        });
-        if (typeof process !== "undefined" && process.env) {
-          process.env.DEBUG = enabled ? enabled === true ? "2" : String(enabled) : "0";
-        }
-      }
-      static setFormat(format) {
-        this.currentFormat = format;
-        this.configure({ format });
-      }
-    };
-    if (isNodeJSEnvironment()) {
-      loadWinstonSync();
-      if (winston) {
-        Logger.configure();
-      }
-    }
-    logger = Logger.get();
-  }
-});
-
 // src/telemetry/events.ts
 function createServerRunEventData(server, transport) {
   const toolRegistrations = Array.from(server.registrations.tools.values());
@@ -468,7 +100,7 @@ function createServerRunEventData(server, transport) {
     mcpAppsResourcesNumber: mcpAppsResources.length
   };
 }
-var BaseTelemetryEvent, MCPAgentExecutionEvent, ServerRunEvent, ServerInitializeEvent, ServerToolCallEvent, ServerResourceCallEvent, ServerPromptCallEvent, ServerContextEvent, MCPClientInitEvent, ConnectorInitEvent;
+var BaseTelemetryEvent, MCPAgentExecutionEvent, ServerRunEvent, ServerInitializeEvent, ServerToolCallEvent, ServerResourceCallEvent, ServerPromptCallEvent, ServerContextEvent, MCPClientInitEvent, ConnectorInitEvent, ClientAddServerEvent, ClientRemoveServerEvent;
 var init_events = __esm({
   "src/telemetry/events.ts"() {
     "use strict";
@@ -622,87 +254,502 @@ var init_events = __esm({
         };
       }
     };
-    ServerPromptCallEvent = class extends BaseTelemetryEvent {
+    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
+        };
+      }
+    };
+    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
+        };
+      }
+    };
+    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
+        };
+      }
+    };
+    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
+        };
+      }
+    };
+    ClientAddServerEvent = class extends BaseTelemetryEvent {
       constructor(data) {
         super();
         this.data = data;
       }
       static {
-        __name(this, "ServerPromptCallEvent");
+        __name(this, "ClientAddServerEvent");
       }
       get name() {
-        return "server_prompt_call";
+        return "client_add_server";
       }
       get properties() {
+        const { serverName, serverConfig } = this.data;
+        const url = serverConfig.url;
         return {
-          name: this.data.name,
-          description: this.data.description,
-          success: this.data.success,
-          error_type: this.data.errorType ?? null
+          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;
+        }
+      }
     };
-    ServerContextEvent = class extends BaseTelemetryEvent {
+    ClientRemoveServerEvent = class extends BaseTelemetryEvent {
       constructor(data) {
         super();
         this.data = data;
       }
       static {
-        __name(this, "ServerContextEvent");
+        __name(this, "ClientRemoveServerEvent");
       }
       get name() {
-        return `server_context_${this.data.contextType}`;
+        return "client_remove_server";
       }
       get properties() {
         return {
-          context_type: this.data.contextType,
-          notification_type: this.data.notificationType ?? null
+          server_name: this.data.serverName
         };
       }
-    };
-    MCPClientInitEvent = class extends BaseTelemetryEvent {
-      constructor(data) {
-        super();
-        this.data = data;
+    };
+  }
+});
+
+// src/server/utils/runtime.ts
+function getEnv(key) {
+  if (isDeno) {
+    return globalThis.Deno.env.get(key);
+  }
+  return process.env[key];
+}
+function getCwd() {
+  if (isDeno) {
+    return globalThis.Deno.cwd();
+  }
+  return process.cwd();
+}
+function generateUUID() {
+  return globalThis.crypto.randomUUID();
+}
+var isDeno, fsHelpers, pathHelpers;
+var init_runtime = __esm({
+  "src/server/utils/runtime.ts"() {
+    "use strict";
+    isDeno = typeof globalThis.Deno !== "undefined";
+    __name(getEnv, "getEnv");
+    __name(getCwd, "getCwd");
+    fsHelpers = {
+      async readFileSync(path, encoding = "utf8") {
+        if (isDeno) {
+          return await globalThis.Deno.readTextFile(path);
+        }
+        const { readFileSync } = await import("fs");
+        const result = readFileSync(path, encoding);
+        return typeof result === "string" ? result : result.toString(encoding);
+      },
+      async readFile(path) {
+        if (isDeno) {
+          const data = await globalThis.Deno.readFile(path);
+          return data.buffer;
+        }
+        const { readFileSync } = await import("fs");
+        const buffer = readFileSync(path);
+        return buffer.buffer.slice(
+          buffer.byteOffset,
+          buffer.byteOffset + buffer.byteLength
+        );
+      },
+      async existsSync(path) {
+        if (isDeno) {
+          try {
+            await globalThis.Deno.stat(path);
+            return true;
+          } catch {
+            return false;
+          }
+        }
+        const { existsSync } = await import("fs");
+        return existsSync(path);
+      },
+      async readdirSync(path) {
+        if (isDeno) {
+          const entries = [];
+          for await (const entry of globalThis.Deno.readDir(path)) {
+            entries.push(entry.name);
+          }
+          return entries;
+        }
+        const { readdirSync } = await import("fs");
+        return readdirSync(path);
+      }
+    };
+    pathHelpers = {
+      join(...paths) {
+        if (isDeno) {
+          return paths.join("/").replace(/\/+/g, "/");
+        }
+        return paths.join("/").replace(/\/+/g, "/");
+      },
+      relative(from, to) {
+        const fromParts = from.split("/").filter((p) => p);
+        const toParts = to.split("/").filter((p) => p);
+        let i = 0;
+        while (i < fromParts.length && i < toParts.length && fromParts[i] === toParts[i]) {
+          i++;
+        }
+        const upCount = fromParts.length - i;
+        const relativeParts = [...Array(upCount).fill(".."), ...toParts.slice(i)];
+        return relativeParts.join("/");
+      }
+    };
+    __name(generateUUID, "generateUUID");
+  }
+});
+
+// src/logging.ts
+async function getNodeModules() {
+  if (typeof process !== "undefined" && process.platform) {
+    try {
+      const fs = await import("fs");
+      const path = await import("path");
+      return { fs: fs.default, path: path.default };
+    } catch {
+      return { fs: null, path: null };
+    }
+  }
+  return { fs: null, path: null };
+}
+function loadWinstonSync() {
+  if (typeof require !== "undefined") {
+    try {
+      winston = require("winston");
+    } catch {
+    }
+  }
+}
+async function getWinston() {
+  if (!winston) {
+    winston = await import("winston");
+  }
+  return winston;
+}
+function isNodeJSEnvironment() {
+  try {
+    if (typeof navigator !== "undefined" && navigator.userAgent?.includes("Cloudflare-Workers")) {
+      return false;
+    }
+    if (typeof globalThis.EdgeRuntime !== "undefined" || typeof globalThis.Deno !== "undefined") {
+      return false;
+    }
+    const hasNodeGlobals = typeof process !== "undefined" && typeof process.platform !== "undefined" && typeof __dirname !== "undefined";
+    return hasNodeGlobals;
+  } catch {
+    return false;
+  }
+}
+function resolveLevel(env) {
+  const envValue = typeof process !== "undefined" && process.env ? env : void 0;
+  switch (envValue?.trim()) {
+    case "2":
+      return "debug";
+    case "1":
+      return "info";
+    default:
+      return "info";
+  }
+}
+var winston, DEFAULT_LOGGER_NAME, SimpleConsoleLogger, Logger, logger;
+var init_logging = __esm({
+  "src/logging.ts"() {
+    "use strict";
+    __name(getNodeModules, "getNodeModules");
+    winston = null;
+    __name(loadWinstonSync, "loadWinstonSync");
+    __name(getWinston, "getWinston");
+    DEFAULT_LOGGER_NAME = "mcp-use";
+    __name(isNodeJSEnvironment, "isNodeJSEnvironment");
+    SimpleConsoleLogger = class {
+      static {
+        __name(this, "SimpleConsoleLogger");
+      }
+      _level;
+      name;
+      constructor(name = DEFAULT_LOGGER_NAME, level = "info") {
+        this.name = name;
+        this._level = level;
+      }
+      shouldLog(level) {
+        const levels = [
+          "error",
+          "warn",
+          "info",
+          "http",
+          "verbose",
+          "debug",
+          "silly"
+        ];
+        const currentIndex = levels.indexOf(this._level);
+        const messageIndex = levels.indexOf(level);
+        return messageIndex <= currentIndex;
+      }
+      formatMessage(level, message) {
+        const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+        return `${timestamp} [${this.name}] ${level}: ${message}`;
+      }
+      error(message) {
+        if (this.shouldLog("error")) {
+          console.error(this.formatMessage("error", message));
+        }
+      }
+      warn(message) {
+        if (this.shouldLog("warn")) {
+          console.warn(this.formatMessage("warn", message));
+        }
+      }
+      info(message) {
+        if (this.shouldLog("info")) {
+          console.info(this.formatMessage("info", message));
+        }
+      }
+      debug(message) {
+        if (this.shouldLog("debug")) {
+          console.debug(this.formatMessage("debug", message));
+        }
+      }
+      http(message) {
+        if (this.shouldLog("http")) {
+          console.log(this.formatMessage("http", message));
+        }
+      }
+      verbose(message) {
+        if (this.shouldLog("verbose")) {
+          console.log(this.formatMessage("verbose", message));
+        }
+      }
+      silly(message) {
+        if (this.shouldLog("silly")) {
+          console.log(this.formatMessage("silly", message));
+        }
+      }
+      // Make it compatible with Winston interface
+      get level() {
+        return this._level;
+      }
+      set level(newLevel) {
+        this._level = newLevel;
+      }
+    };
+    __name(resolveLevel, "resolveLevel");
+    Logger = class {
+      static {
+        __name(this, "Logger");
+      }
+      static instances = {};
+      static simpleInstances = {};
+      static currentFormat = "minimal";
+      static get(name = DEFAULT_LOGGER_NAME) {
+        if (!isNodeJSEnvironment()) {
+          if (!this.simpleInstances[name]) {
+            const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || void 0;
+            this.simpleInstances[name] = new SimpleConsoleLogger(
+              name,
+              resolveLevel(debugEnv)
+            );
+          }
+          return this.simpleInstances[name];
+        }
+        if (!this.instances[name]) {
+          if (!winston) {
+            throw new Error("Winston not loaded - call Logger.configure() first");
+          }
+          const { createLogger, format } = winston;
+          const { combine, timestamp, label, colorize, splat } = format;
+          this.instances[name] = createLogger({
+            level: resolveLevel(process.env.DEBUG),
+            format: combine(
+              colorize(),
+              splat(),
+              label({ label: name }),
+              timestamp({ format: "HH:mm:ss" }),
+              this.getFormatter()
+            ),
+            transports: []
+          });
+        }
+        return this.instances[name];
+      }
+      static getFormatter() {
+        if (!winston) {
+          throw new Error("Winston not loaded");
+        }
+        const { format } = winston;
+        const { printf } = format;
+        const minimalFormatter = printf(({ level, message, label, timestamp }) => {
+          return `${timestamp} [${label}] ${level}: ${message}`;
+        });
+        const detailedFormatter = printf(({ level, message, label, timestamp }) => {
+          return `${timestamp} [${label}] ${level.toUpperCase()}: ${message}`;
+        });
+        const emojiFormatter = printf(({ level, message, label, timestamp }) => {
+          return `${timestamp} [${label}] ${level.toUpperCase()}: ${message}`;
+        });
+        switch (this.currentFormat) {
+          case "minimal":
+            return minimalFormatter;
+          case "detailed":
+            return detailedFormatter;
+          case "emoji":
+            return emojiFormatter;
+          default:
+            return minimalFormatter;
+        }
       }
-      static {
-        __name(this, "MCPClientInitEvent");
+      static async configure(options = {}) {
+        const { level, console: console2 = true, file, format = "minimal" } = options;
+        const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || void 0;
+        const resolvedLevel = level ?? resolveLevel(debugEnv);
+        this.currentFormat = format;
+        if (!isNodeJSEnvironment()) {
+          Object.values(this.simpleInstances).forEach((logger2) => {
+            logger2.level = resolvedLevel;
+          });
+          return;
+        }
+        await getWinston();
+        if (!winston) {
+          throw new Error("Failed to load winston");
+        }
+        const root = this.get();
+        root.level = resolvedLevel;
+        const winstonRoot = root;
+        winstonRoot.clear();
+        if (console2) {
+          winstonRoot.add(new winston.transports.Console());
+        }
+        if (file) {
+          const { fs: nodeFs, path: nodePath } = await getNodeModules();
+          if (nodeFs && nodePath) {
+            const dir = nodePath.dirname(nodePath.resolve(file));
+            if (!nodeFs.existsSync(dir)) {
+              nodeFs.mkdirSync(dir, { recursive: true });
+            }
+            winstonRoot.add(new winston.transports.File({ filename: file }));
+          }
+        }
+        const { format: winstonFormat } = winston;
+        const { combine, timestamp, label, colorize, splat } = winstonFormat;
+        Object.values(this.instances).forEach((logger2) => {
+          if (logger2 && "format" in logger2) {
+            logger2.level = resolvedLevel;
+            logger2.format = combine(
+              colorize(),
+              splat(),
+              label({ label: DEFAULT_LOGGER_NAME }),
+              timestamp({ format: "HH:mm:ss" }),
+              this.getFormatter()
+            );
+          }
+        });
       }
-      get name() {
-        return "mcpclient_init";
+      static setDebug(enabled) {
+        let level;
+        if (enabled === 2 || enabled === true) level = "debug";
+        else if (enabled === 1) level = "info";
+        else level = "info";
+        Object.values(this.simpleInstances).forEach((logger2) => {
+          logger2.level = level;
+        });
+        Object.values(this.instances).forEach((logger2) => {
+          if (logger2) {
+            logger2.level = level;
+          }
+        });
+        if (typeof process !== "undefined" && process.env) {
+          process.env.DEBUG = enabled ? enabled === true ? "2" : String(enabled) : "0";
+        }
       }
-      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
-        };
+      static setFormat(format) {
+        this.currentFormat = format;
+        this.configure({ format });
       }
     };
-    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
-        };
+    if (isNodeJSEnvironment()) {
+      loadWinstonSync();
+      if (winston) {
+        Logger.configure();
       }
-    };
+    }
+    logger = Logger.get();
   }
 });
 
@@ -714,7 +761,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "1.10.0-canary.8";
+    VERSION = "1.10.0";
     __name(getPackageVersion, "getPackageVersion");
   }
 });
@@ -742,12 +789,12 @@ function detectRuntimeEnvironment() {
     if (typeof globalThis.EdgeRuntime !== "undefined") {
       return "edge";
     }
-    if (typeof process !== "undefined" && typeof process.versions?.node !== "undefined" && typeof fs !== "undefined" && typeof fs.existsSync === "function") {
-      return "node";
-    }
     if (typeof window !== "undefined" && typeof document !== "undefined") {
       return "browser";
     }
+    if (typeof process !== "undefined" && typeof process.versions?.node !== "undefined") {
+      return "node";
+    }
     return "unknown";
   } catch {
     return "unknown";
@@ -780,40 +827,10 @@ function getRuntimeEnvironment() {
   }
   return cachedEnvironment;
 }
-function isNodeJSEnvironment2() {
-  const env = getRuntimeEnvironment();
-  return env === "node" || env === "bun";
-}
-function getCacheHome() {
-  if (!isNodeJSEnvironment2()) {
-    return "/tmp/mcp_use_cache";
-  }
-  const envVar = process.env.XDG_CACHE_HOME;
-  if (envVar && path.isAbsolute(envVar)) {
-    return envVar;
-  }
-  const platform = process.platform;
-  const homeDir = os.homedir();
-  if (platform === "win32") {
-    const appdata = process.env.LOCALAPPDATA || process.env.APPDATA;
-    if (appdata) {
-      return appdata;
-    }
-    return path.join(homeDir, "AppData", "Local");
-  } else if (platform === "darwin") {
-    return path.join(homeDir, "Library", "Caches");
-  } else {
-    return path.join(homeDir, ".cache");
-  }
-}
-var fs, os, path, import_posthog_node, USER_ID_STORAGE_KEY, cachedEnvironment, ScarfEventLogger, Telemetry;
+var USER_ID_STORAGE_KEY, cachedEnvironment, ScarfEventLogger, Telemetry;
 var init_telemetry = __esm({
   "src/telemetry/telemetry.ts"() {
     "use strict";
-    fs = __toESM(require("fs"), 1);
-    os = __toESM(require("os"), 1);
-    path = __toESM(require("path"), 1);
-    import_posthog_node = require("posthog-node");
     init_runtime();
     init_logging();
     init_events();
@@ -823,7 +840,6 @@ var init_telemetry = __esm({
     __name(getStorageCapability, "getStorageCapability");
     cachedEnvironment = null;
     __name(getRuntimeEnvironment, "getRuntimeEnvironment");
-    __name(isNodeJSEnvironment2, "isNodeJSEnvironment");
     ScarfEventLogger = class {
       static {
         __name(this, "ScarfEventLogger");
@@ -855,49 +871,40 @@ var init_telemetry = __esm({
         }
       }
     };
-    __name(getCacheHome, "getCacheHome");
     Telemetry = class _Telemetry {
       static {
         __name(this, "Telemetry");
       }
       static instance = null;
-      USER_ID_PATH = path.join(
-        getCacheHome(),
-        "mcp_use_3",
-        "telemetry_user_id"
-      );
-      VERSION_DOWNLOAD_PATH = path.join(
-        getCacheHome(),
-        "mcp_use",
-        "download_version"
-      );
       PROJECT_API_KEY = "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI";
       HOST = "https://eu.i.posthog.com";
       SCARF_GATEWAY_URL = "https://mcpuse.gateway.scarf.sh/events-ts";
       UNKNOWN_USER_ID = "UNKNOWN_USER_ID";
       _currUserId = null;
-      _posthogClient = null;
+      _posthogNodeClient = null;
+      _posthogBrowserClient = null;
+      _posthogLoading = null;
       _scarfClient = null;
       _runtimeEnvironment;
       _storageCapability;
       _source;
+      // Node.js specific paths (lazily computed)
+      _userIdPath = null;
+      _versionDownloadPath = null;
       constructor() {
         this._runtimeEnvironment = getRuntimeEnvironment();
         this._storageCapability = getStorageCapability(this._runtimeEnvironment);
         this._source = typeof process !== "undefined" && process.env?.MCP_USE_TELEMETRY_SOURCE || this._runtimeEnvironment;
-        const telemetryDisabled = typeof process !== "undefined" && process.env?.MCP_USE_ANONYMIZED_TELEMETRY?.toLowerCase() === "false" || false;
+        const telemetryDisabled = this._checkTelemetryDisabled();
         const canSupportTelemetry = this._runtimeEnvironment !== "unknown";
-        const isServerlessEnvironment = [
-          "cloudflare-workers",
-          "edge",
-          "deno"
-        ].includes(this._runtimeEnvironment);
         if (telemetryDisabled) {
-          this._posthogClient = null;
+          this._posthogNodeClient = null;
+          this._posthogBrowserClient = null;
           this._scarfClient = null;
-          logger.debug("Telemetry disabled via environment variable");
+          logger.debug("Telemetry disabled via environment/localStorage");
         } else if (!canSupportTelemetry) {
-          this._posthogClient = null;
+          this._posthogNodeClient = null;
+          this._posthogBrowserClient = null;
           this._scarfClient = null;
           logger.debug(
             `Telemetry disabled - unknown environment: ${this._runtimeEnvironment}`
@@ -906,27 +913,7 @@ var init_telemetry = __esm({
           logger.info(
             "Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable."
           );
-          if (this._runtimeEnvironment !== "browser") {
-            try {
-              const posthogOptions = {
-                host: this.HOST,
-                disableGeoip: false
-              };
-              if (isServerlessEnvironment) {
-                posthogOptions.flushAt = 1;
-                posthogOptions.flushInterval = 0;
-              }
-              this._posthogClient = new import_posthog_node.PostHog(
-                this.PROJECT_API_KEY,
-                posthogOptions
-              );
-            } catch (e) {
-              logger.warn(`Failed to initialize PostHog telemetry: ${e}`);
-              this._posthogClient = null;
-            }
-          } else {
-            this._posthogClient = null;
-          }
+          this._posthogLoading = this._initPostHog();
           try {
             this._scarfClient = new ScarfEventLogger(this.SCARF_GATEWAY_URL, 3e3);
           } catch (e) {
@@ -935,6 +922,75 @@ var init_telemetry = __esm({
           }
         }
       }
+      _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
        */
@@ -970,10 +1026,9 @@ var init_telemetry = __esm({
       }
       /**
        * Check if telemetry is enabled.
-       * Returns false if telemetry was disabled via environment variable or if not in Node.js environment.
        */
       get isEnabled() {
-        return this._posthogClient !== null || this._scarfClient !== null;
+        return this._posthogNodeClient !== null || this._posthogBrowserClient !== null || this._scarfClient !== null;
       }
       get userId() {
         if (this._currUserId) {
@@ -982,10 +1037,10 @@ var init_telemetry = __esm({
         try {
           switch (this._storageCapability) {
             case "filesystem":
-              this._currUserId = this.getUserIdFromFilesystem();
+              this._currUserId = this._getUserIdFromFilesystem();
               break;
             case "localStorage":
-              this._currUserId = this.getUserIdFromLocalStorage();
+              this._currUserId = this._getUserIdFromLocalStorage();
               break;
             case "session-only":
             default:
@@ -996,7 +1051,7 @@ var init_telemetry = __esm({
               break;
           }
           if (this._storageCapability === "filesystem" && this._currUserId) {
-            this.trackPackageDownloadInternal(this._currUserId, {
+            this._trackPackageDownloadInternal(this._currUserId, {
               triggered_by: "user_id_property"
             }).catch((e) => logger.debug(`Failed to track package download: ${e}`));
           }
@@ -1009,22 +1064,32 @@ var init_telemetry = __esm({
       /**
        * Get or create user ID from filesystem (Node.js/Bun)
        */
-      getUserIdFromFilesystem() {
-        const isFirstTime = !fs.existsSync(this.USER_ID_PATH);
+      _getUserIdFromFilesystem() {
+        const fs = require("fs");
+        const os = require("os");
+        const path = require("path");
+        if (!this._userIdPath) {
+          this._userIdPath = path.join(
+            this._getCacheHome(os, path),
+            "mcp_use_3",
+            "telemetry_user_id"
+          );
+        }
+        const isFirstTime = !fs.existsSync(this._userIdPath);
         if (isFirstTime) {
-          logger.debug(`Creating user ID path: ${this.USER_ID_PATH}`);
-          fs.mkdirSync(path.dirname(this.USER_ID_PATH), { recursive: true });
+          logger.debug(`Creating user ID path: ${this._userIdPath}`);
+          fs.mkdirSync(path.dirname(this._userIdPath), { recursive: true });
           const newUserId = generateUUID();
-          fs.writeFileSync(this.USER_ID_PATH, newUserId);
-          logger.debug(`User ID path created: ${this.USER_ID_PATH}`);
+          fs.writeFileSync(this._userIdPath, newUserId);
+          logger.debug(`User ID path created: ${this._userIdPath}`);
           return newUserId;
         }
-        return fs.readFileSync(this.USER_ID_PATH, "utf-8").trim();
+        return fs.readFileSync(this._userIdPath, "utf-8").trim();
       }
       /**
        * Get or create user ID from localStorage (Browser)
        */
-      getUserIdFromLocalStorage() {
+      _getUserIdFromLocalStorage() {
         try {
           let userId = localStorage.getItem(USER_ID_STORAGE_KEY);
           if (!userId) {
@@ -1038,60 +1103,89 @@ var init_telemetry = __esm({
           return `session-${generateUUID()}`;
         }
       }
+      _getCacheHome(os, path) {
+        const envVar = process.env.XDG_CACHE_HOME;
+        if (envVar && path.isAbsolute(envVar)) {
+          return envVar;
+        }
+        const platform = process.platform;
+        const homeDir = os.homedir();
+        if (platform === "win32") {
+          const appdata = process.env.LOCALAPPDATA || process.env.APPDATA;
+          if (appdata) {
+            return appdata;
+          }
+          return path.join(homeDir, "AppData", "Local");
+        } else if (platform === "darwin") {
+          return path.join(homeDir, "Library", "Caches");
+        } else {
+          return path.join(homeDir, ".cache");
+        }
+      }
       async capture(event) {
-        logger.debug(
-          `CAPTURE: posthog: ${this._posthogClient !== null}, scarf: ${this._scarfClient !== null}`
-        );
-        if (!this._posthogClient && !this._scarfClient) {
+        if (this._posthogLoading) {
+          await this._posthogLoading;
+        }
+        if (!this._posthogNodeClient && !this._posthogBrowserClient && !this._scarfClient) {
           return;
         }
-        if (this._posthogClient) {
+        const properties = { ...event.properties };
+        properties.mcp_use_version = getPackageVersion();
+        properties.language = "typescript";
+        properties.source = this._source;
+        properties.runtime = this._runtimeEnvironment;
+        if (this._posthogNodeClient) {
           try {
-            const properties = { ...event.properties };
-            properties.mcp_use_version = getPackageVersion();
-            properties.language = "typescript";
-            properties.source = this._source;
-            properties.runtime = this._runtimeEnvironment;
-            logger.debug(`CAPTURE: PostHog Event ${event.name}`);
-            logger.debug(
-              `CAPTURE: PostHog Properties ${JSON.stringify(properties)}`
-            );
-            this._posthogClient.capture({
+            logger.debug(`CAPTURE: PostHog Node Event ${event.name}`);
+            this._posthogNodeClient.capture({
               distinctId: this.userId,
               event: event.name,
               properties
             });
           } catch (e) {
-            logger.debug(`Failed to track PostHog event ${event.name}: ${e}`);
+            logger.debug(`Failed to track PostHog Node event ${event.name}: ${e}`);
+          }
+        }
+        if (this._posthogBrowserClient) {
+          try {
+            logger.debug(`CAPTURE: PostHog Browser Event ${event.name}`);
+            this._posthogBrowserClient.capture(event.name, {
+              ...properties,
+              distinct_id: this.userId
+            });
+          } catch (e) {
+            logger.debug(
+              `Failed to track PostHog Browser event ${event.name}: ${e}`
+            );
           }
         }
         if (this._scarfClient) {
           try {
-            const properties = {};
-            properties.mcp_use_version = getPackageVersion();
-            properties.user_id = this.userId;
-            properties.event = event.name;
-            properties.language = "typescript";
-            properties.source = this._source;
-            properties.runtime = this._runtimeEnvironment;
-            await this._scarfClient.logEvent(properties);
+            const scarfProperties = {
+              ...properties,
+              user_id: this.userId,
+              event: event.name
+            };
+            await this._scarfClient.logEvent(scarfProperties);
           } catch (e) {
             logger.debug(`Failed to track Scarf event ${event.name}: ${e}`);
           }
         }
       }
+      // ============================================================================
+      // Package Download Tracking (Node.js only)
+      // ============================================================================
       /**
        * Track package download event.
        * This is a public wrapper that safely accesses userId.
        */
       async trackPackageDownload(properties) {
-        return this.trackPackageDownloadInternal(this.userId, properties);
+        return this._trackPackageDownloadInternal(this.userId, properties);
       }
       /**
        * Internal method to track package download with explicit userId.
-       * This avoids circular dependency when called from the userId getter.
        */
-      async trackPackageDownloadInternal(userId, properties) {
+      async _trackPackageDownloadInternal(userId, properties) {
         if (!this._scarfClient) {
           return;
         }
@@ -1099,22 +1193,32 @@ var init_telemetry = __esm({
           return;
         }
         try {
+          const fs = require("fs");
+          const path = require("path");
+          const os = require("os");
+          if (!this._versionDownloadPath) {
+            this._versionDownloadPath = path.join(
+              this._getCacheHome(os, path),
+              "mcp_use",
+              "download_version"
+            );
+          }
           const currentVersion = getPackageVersion();
           let shouldTrack = false;
           let firstDownload = false;
-          if (!fs.existsSync(this.VERSION_DOWNLOAD_PATH)) {
+          if (!fs.existsSync(this._versionDownloadPath)) {
             shouldTrack = true;
             firstDownload = true;
-            fs.mkdirSync(path.dirname(this.VERSION_DOWNLOAD_PATH), {
+            fs.mkdirSync(path.dirname(this._versionDownloadPath), {
               recursive: true
             });
-            fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
+            fs.writeFileSync(this._versionDownloadPath, currentVersion);
           } else {
-            const savedVersion = fs.readFileSync(this.VERSION_DOWNLOAD_PATH, "utf-8").trim();
+            const savedVersion = fs.readFileSync(this._versionDownloadPath, "utf-8").trim();
             if (currentVersion > savedVersion) {
               shouldTrack = true;
               firstDownload = false;
-              fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
+              fs.writeFileSync(this._versionDownloadPath, currentVersion);
             }
           }
           if (shouldTrack) {
@@ -1148,9 +1252,6 @@ var init_telemetry = __esm({
       // ============================================================================
       /**
        * 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;
@@ -1196,31 +1297,118 @@ var init_telemetry = __esm({
         const event = new ConnectorInitEvent(data);
         await this.capture(event);
       }
+      async trackClientAddServer(serverName, serverConfig) {
+        if (!this.isEnabled) return;
+        const event = new ClientAddServerEvent({ serverName, serverConfig });
+        await this.capture(event);
+      }
+      async trackClientRemoveServer(serverName) {
+        if (!this.isEnabled) return;
+        const event = new ClientRemoveServerEvent({ serverName });
+        await this.capture(event);
+      }
+      // ============================================================================
+      // React Hook / Browser specific events
+      // ============================================================================
+      async trackUseMcpConnection(data) {
+        if (!this.isEnabled) return;
+        await this.capture({
+          name: "usemcp_connection",
+          properties: {
+            url_domain: new URL(data.url).hostname,
+            // Only domain for privacy
+            transport_type: data.transportType,
+            success: data.success,
+            error_type: data.errorType ?? null,
+            connection_time_ms: data.connectionTimeMs ?? null,
+            has_oauth: data.hasOAuth,
+            has_sampling: data.hasSampling,
+            has_elicitation: data.hasElicitation
+          }
+        });
+      }
+      async trackUseMcpToolCall(data) {
+        if (!this.isEnabled) return;
+        await this.capture({
+          name: "usemcp_tool_call",
+          properties: {
+            tool_name: data.toolName,
+            success: data.success,
+            error_type: data.errorType ?? null,
+            execution_time_ms: data.executionTimeMs ?? null
+          }
+        });
+      }
+      async trackUseMcpResourceRead(data) {
+        if (!this.isEnabled) return;
+        await this.capture({
+          name: "usemcp_resource_read",
+          properties: {
+            resource_uri_scheme: data.resourceUri.split(":")[0],
+            // Only scheme for privacy
+            success: data.success,
+            error_type: data.errorType ?? null
+          }
+        });
+      }
+      // ============================================================================
+      // Browser-specific Methods
+      // ============================================================================
+      /**
+       * Identify the current user (useful for linking sessions)
+       * Browser only - no-op in Node.js
+       */
+      identify(userId, properties) {
+        if (this._posthogBrowserClient) {
+          try {
+            this._posthogBrowserClient.identify(userId, properties);
+          } catch (e) {
+            logger.debug(`Failed to identify user: ${e}`);
+          }
+        }
+      }
+      /**
+       * Reset the user identity (useful for logout)
+       * Browser only - no-op in Node.js
+       */
+      reset() {
+        if (this._posthogBrowserClient) {
+          try {
+            this._posthogBrowserClient.reset();
+          } catch (e) {
+            logger.debug(`Failed to reset user: ${e}`);
+          }
+        }
+        this._currUserId = null;
+      }
+      // ============================================================================
+      // Node.js-specific Methods
+      // ============================================================================
+      /**
+       * Flush the telemetry queue (Node.js only)
+       */
       flush() {
-        if (this._posthogClient) {
+        if (this._posthogNodeClient) {
           try {
-            this._posthogClient.flush();
+            this._posthogNodeClient.flush();
             logger.debug("PostHog client telemetry queue flushed");
           } catch (e) {
             logger.debug(`Failed to flush PostHog client: ${e}`);
           }
         }
-        if (this._scarfClient) {
-          logger.debug("Scarf telemetry events sent immediately (no flush needed)");
-        }
       }
+      /**
+       * Shutdown the telemetry client (Node.js only)
+       */
       shutdown() {
-        if (this._posthogClient) {
+        if (this._posthogNodeClient) {
           try {
-            this._posthogClient.shutdown();
+            this._posthogNodeClient.shutdown();
             logger.debug("PostHog client shutdown successfully");
           } catch (e) {
             logger.debug(`Error shutting down PostHog client: ${e}`);
           }
         }
-        if (this._scarfClient) {
-          logger.debug("Scarf telemetry client shutdown (no action needed)");
-        }
       }
     };
   }
@@ -1230,7 +1418,6 @@ var init_telemetry = __esm({
 var init_telemetry2 = __esm({
   "src/telemetry/index.ts"() {
     "use strict";
-    init_telemetry();
     init_events();
     init_telemetry();
     init_utils();
@@ -2629,11 +2816,11 @@ function createHonoProxy(target, app) {
       if (prop === "use") {
         return async (...args) => {
           const hasPath = typeof args[0] === "string";
-          const path2 = hasPath ? args[0] : "*";
+          const path = hasPath ? args[0] : "*";
           const handlers = hasPath ? args.slice(1) : args;
           const adaptedHandlers = handlers.map((handler) => {
             if (isExpressMiddleware(handler)) {
-              return { __isExpressMiddleware: true, handler, path: path2 };
+              return { __isExpressMiddleware: true, handler, path };
             }
             return handler;
           });
@@ -2649,13 +2836,13 @@ function createHonoProxy(target, app) {
                     h.path
                   );
                   if (hasPath) {
-                    app.use(path2, adapted);
+                    app.use(path, adapted);
                   } else {
                     app.use(adapted);
                   }
                 } else {
                   if (hasPath) {
-                    app.use(path2, h);
+                    app.use(path, h);
                   } else {
                     app.use(h);
                   }
@@ -3066,12 +3253,12 @@ __name(setupPublicRoutes, "setupPublicRoutes");
 // src/server/widgets/mount-widgets-dev.ts
 var TMP_MCP_USE_DIR = ".mcp-use";
 async function mountWidgetsDev(app, serverConfig, registerWidget, options) {
-  const { promises: fs2 } = await import("fs");
+  const { promises: fs } = await import("fs");
   const baseRoute = options?.baseRoute || "/mcp-use/widgets";
   const resourcesDir = options?.resourcesDir || "resources";
   const srcDir = pathHelpers.join(getCwd(), resourcesDir);
   try {
-    await fs2.access(srcDir);
+    await fs.access(srcDir);
   } catch (error2) {
     console.log(
       `[WIDGETS] No ${resourcesDir}/ directory found - skipping widget serving`
@@ -3080,7 +3267,7 @@ async function mountWidgetsDev(app, serverConfig, registerWidget, options) {
   }
   const entries = [];
   try {
-    const files = await fs2.readdir(srcDir, { withFileTypes: true });
+    const files = await fs.readdir(srcDir, { withFileTypes: true });
     for (const dirent of files) {
       if (dirent.name.startsWith("._") || dirent.name.startsWith(".DS_Store")) {
         continue;
@@ -3093,7 +3280,7 @@ async function mountWidgetsDev(app, serverConfig, registerWidget, options) {
       } else if (dirent.isDirectory()) {
         const widgetPath = pathHelpers.join(srcDir, dirent.name, "widget.tsx");
         try {
-          await fs2.access(widgetPath);
+          await fs.access(widgetPath);
           entries.push({
             name: dirent.name,
             path: widgetPath
@@ -3111,7 +3298,7 @@ async function mountWidgetsDev(app, serverConfig, registerWidget, options) {
     return;
   }
   const tempDir = pathHelpers.join(getCwd(), TMP_MCP_USE_DIR);
-  await fs2.mkdir(tempDir, { recursive: true }).catch(() => {
+  await fs.mkdir(tempDir, { recursive: true }).catch(() => {
   });
   let createServer;
   let react;
@@ -3145,7 +3332,7 @@ async function mountWidgetsDev(app, serverConfig, registerWidget, options) {
   });
   for (const widget2 of widgets) {
     const widgetTempDir = pathHelpers.join(tempDir, widget2.name);
-    await fs2.mkdir(widgetTempDir, { recursive: true });
+    await fs.mkdir(widgetTempDir, { recursive: true });
     const resourcesPath = pathHelpers.join(getCwd(), resourcesDir);
     const relativeResourcesPath = pathHelpers.relative(widgetTempDir, resourcesPath).replace(/\\/g, "/");
     const cssContent = `@import "tailwindcss";
@@ -3153,7 +3340,7 @@ async function mountWidgetsDev(app, serverConfig, registerWidget, options) {
 /* Configure Tailwind to scan the resources directory */
 @source "${relativeResourcesPath}";
 `;
-    await fs2.writeFile(
+    await fs.writeFile(
       pathHelpers.join(widgetTempDir, "styles.css"),
       cssContent,
       "utf8"
@@ -3181,12 +3368,12 @@ if (container && Component) {
     <script type="module" src="${baseRoute}/${widget2.name}/entry.tsx"></script>
   </body>
 </html>`;
-    await fs2.writeFile(
+    await fs.writeFile(
       pathHelpers.join(widgetTempDir, "entry.tsx"),
       entryContent,
       "utf8"
     );
-    await fs2.writeFile(
+    await fs.writeFile(
       pathHelpers.join(widgetTempDir, "index.html"),
       htmlContent,
       "utf8"