mcp-use 1.10.0-canary.9 → 1.10.0

package/dist/{chunk-467MICF6.js → chunk-X5EWD2UY.js}

@@ -2,7 +2,8 @@ import {
   logger
 } from "./chunk-34R6SIER.js";
 import {
-  __name
+  __name,
+  __require
 } from "./chunk-3GQAWCBQ.js";
 
 // src/server/utils/runtime.ts
@@ -22,48 +23,48 @@ function getCwd() {
 }
 __name(getCwd, "getCwd");
 var fsHelpers = {
-  async readFileSync(path2, encoding = "utf8") {
+  async readFileSync(path, encoding = "utf8") {
     if (isDeno) {
-      return await globalThis.Deno.readTextFile(path2);
+      return await globalThis.Deno.readTextFile(path);
     }
-    const { readFileSync: readFileSync2 } = await import("fs");
-    const result = readFileSync2(path2, encoding);
+    const { readFileSync } = await import("fs");
+    const result = readFileSync(path, encoding);
     return typeof result === "string" ? result : result.toString(encoding);
   },
-  async readFile(path2) {
+  async readFile(path) {
     if (isDeno) {
-      const data = await globalThis.Deno.readFile(path2);
+      const data = await globalThis.Deno.readFile(path);
       return data.buffer;
     }
-    const { readFileSync: readFileSync2 } = await import("fs");
-    const buffer = readFileSync2(path2);
+    const { readFileSync } = await import("fs");
+    const buffer = readFileSync(path);
     return buffer.buffer.slice(
       buffer.byteOffset,
       buffer.byteOffset + buffer.byteLength
     );
   },
-  async existsSync(path2) {
+  async existsSync(path) {
     if (isDeno) {
       try {
-        await globalThis.Deno.stat(path2);
+        await globalThis.Deno.stat(path);
         return true;
       } catch {
         return false;
       }
     }
-    const { existsSync: existsSync2 } = await import("fs");
-    return existsSync2(path2);
+    const { existsSync } = await import("fs");
+    return existsSync(path);
   },
-  async readdirSync(path2) {
+  async readdirSync(path) {
     if (isDeno) {
       const entries = [];
-      for await (const entry of globalThis.Deno.readDir(path2)) {
+      for await (const entry of globalThis.Deno.readDir(path)) {
         entries.push(entry.name);
       }
       return entries;
     }
     const { readdirSync } = await import("fs");
-    return readdirSync(path2);
+    return readdirSync(path);
   }
 };
 var pathHelpers = {
@@ -91,18 +92,12 @@ function generateUUID() {
 __name(generateUUID, "generateUUID");
 
 // src/version.ts
-var VERSION = "1.10.0-canary.9";
+var VERSION = "1.10.0";
 function getPackageVersion() {
   return VERSION;
 }
 __name(getPackageVersion, "getPackageVersion");
 
-// src/telemetry/telemetry.ts
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { PostHog } from "posthog-node";
-
 // src/telemetry/events.ts
 var BaseTelemetryEvent = class {
   static {
@@ -378,7 +373,8 @@ var MCPClientInitEvent = class extends BaseTelemetryEvent {
       all_callbacks: this.data.allCallbacks,
       verify: this.data.verify,
       servers: this.data.servers,
-      num_servers: this.data.numServers
+      num_servers: this.data.numServers,
+      is_browser: this.data.isBrowser
     };
   }
 };
@@ -403,6 +399,52 @@ var ConnectorInitEvent = class extends BaseTelemetryEvent {
     };
   }
 };
+var ClientAddServerEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ClientAddServerEvent");
+  }
+  get name() {
+    return "client_add_server";
+  }
+  get properties() {
+    const { serverName, serverConfig } = this.data;
+    const url = serverConfig.url;
+    return {
+      server_name: serverName,
+      server_url_domain: url ? this._extractHostname(url) : null,
+      transport: serverConfig.transport ?? null,
+      has_auth: !!(serverConfig.authToken || serverConfig.authProvider)
+    };
+  }
+  _extractHostname(url) {
+    try {
+      return new URL(url).hostname;
+    } catch {
+      return null;
+    }
+  }
+};
+var ClientRemoveServerEvent = class extends BaseTelemetryEvent {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  static {
+    __name(this, "ClientRemoveServerEvent");
+  }
+  get name() {
+    return "client_remove_server";
+  }
+  get properties() {
+    return {
+      server_name: this.data.serverName
+    };
+  }
+};
 
 // src/telemetry/utils.ts
 function getModelProvider(llm) {
@@ -452,12 +494,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";
@@ -494,11 +536,6 @@ function getRuntimeEnvironment() {
   return cachedEnvironment;
 }
 __name(getRuntimeEnvironment, "getRuntimeEnvironment");
-function isNodeJSEnvironment() {
-  const env = getRuntimeEnvironment();
-  return env === "node" || env === "bun";
-}
-__name(isNodeJSEnvironment, "isNodeJSEnvironment");
 var ScarfEventLogger = class {
   static {
     __name(this, "ScarfEventLogger");
@@ -530,71 +567,40 @@ var ScarfEventLogger = class {
     }
   }
 };
-function getCacheHome() {
-  if (!isNodeJSEnvironment()) {
-    return "/tmp/mcp_use_cache";
-  }
-  const envVar = process.env.XDG_CACHE_HOME;
-  if (envVar && path.isAbsolute(envVar)) {
-    return envVar;
-  }
-  const platform = process.platform;
-  const homeDir = os.homedir();
-  if (platform === "win32") {
-    const appdata = process.env.LOCALAPPDATA || process.env.APPDATA;
-    if (appdata) {
-      return appdata;
-    }
-    return path.join(homeDir, "AppData", "Local");
-  } else if (platform === "darwin") {
-    return path.join(homeDir, "Library", "Caches");
-  } else {
-    return path.join(homeDir, ".cache");
-  }
-}
-__name(getCacheHome, "getCacheHome");
 var Telemetry = class _Telemetry {
   static {
     __name(this, "Telemetry");
   }
   static instance = null;
-  USER_ID_PATH = path.join(
-    getCacheHome(),
-    "mcp_use_3",
-    "telemetry_user_id"
-  );
-  VERSION_DOWNLOAD_PATH = path.join(
-    getCacheHome(),
-    "mcp_use",
-    "download_version"
-  );
   PROJECT_API_KEY = "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI";
   HOST = "https://eu.i.posthog.com";
   SCARF_GATEWAY_URL = "https://mcpuse.gateway.scarf.sh/events-ts";
   UNKNOWN_USER_ID = "UNKNOWN_USER_ID";
   _currUserId = null;
-  _posthogClient = null;
+  _posthogNodeClient = null;
+  _posthogBrowserClient = null;
+  _posthogLoading = null;
   _scarfClient = null;
   _runtimeEnvironment;
   _storageCapability;
   _source;
+  // Node.js specific paths (lazily computed)
+  _userIdPath = null;
+  _versionDownloadPath = null;
   constructor() {
     this._runtimeEnvironment = getRuntimeEnvironment();
     this._storageCapability = getStorageCapability(this._runtimeEnvironment);
     this._source = typeof process !== "undefined" && process.env?.MCP_USE_TELEMETRY_SOURCE || this._runtimeEnvironment;
-    const telemetryDisabled = typeof process !== "undefined" && process.env?.MCP_USE_ANONYMIZED_TELEMETRY?.toLowerCase() === "false" || false;
+    const telemetryDisabled = this._checkTelemetryDisabled();
     const canSupportTelemetry = this._runtimeEnvironment !== "unknown";
-    const isServerlessEnvironment = [
-      "cloudflare-workers",
-      "edge",
-      "deno"
-    ].includes(this._runtimeEnvironment);
     if (telemetryDisabled) {
-      this._posthogClient = null;
+      this._posthogNodeClient = null;
+      this._posthogBrowserClient = null;
       this._scarfClient = null;
-      logger.debug("Telemetry disabled via environment variable");
+      logger.debug("Telemetry disabled via environment/localStorage");
     } else if (!canSupportTelemetry) {
-      this._posthogClient = null;
+      this._posthogNodeClient = null;
+      this._posthogBrowserClient = null;
       this._scarfClient = null;
       logger.debug(
         `Telemetry disabled - unknown environment: ${this._runtimeEnvironment}`
@@ -603,27 +609,7 @@ var Telemetry = class _Telemetry {
       logger.info(
         "Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable."
       );
-      if (this._runtimeEnvironment !== "browser") {
-        try {
-          const posthogOptions = {
-            host: this.HOST,
-            disableGeoip: false
-          };
-          if (isServerlessEnvironment) {
-            posthogOptions.flushAt = 1;
-            posthogOptions.flushInterval = 0;
-          }
-          this._posthogClient = new 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) {
@@ -632,6 +618,75 @@ var Telemetry = class _Telemetry {
       }
     }
   }
+  _checkTelemetryDisabled() {
+    if (typeof process !== "undefined" && process.env?.MCP_USE_ANONYMIZED_TELEMETRY?.toLowerCase() === "false") {
+      return true;
+    }
+    if (typeof localStorage !== "undefined" && localStorage.getItem("MCP_USE_ANONYMIZED_TELEMETRY") === "false") {
+      return true;
+    }
+    return false;
+  }
+  async _initPostHog() {
+    const isBrowser = this._runtimeEnvironment === "browser";
+    if (isBrowser) {
+      await this._initPostHogBrowser();
+    } else {
+      await this._initPostHogNode();
+    }
+  }
+  async _initPostHogBrowser() {
+    try {
+      const posthogModule = await import("posthog-js");
+      const posthog = posthogModule.default || posthogModule.posthog;
+      if (!posthog || typeof posthog.init !== "function") {
+        throw new Error("posthog-js module did not export expected interface");
+      }
+      posthog.init(this.PROJECT_API_KEY, {
+        api_host: this.HOST,
+        persistence: "localStorage",
+        autocapture: false,
+        // We only want explicit captures
+        capture_pageview: false,
+        // We don't want automatic pageview tracking
+        disable_session_recording: true,
+        // No session recording
+        loaded: /* @__PURE__ */ __name(() => {
+          logger.debug("PostHog browser client initialized");
+        }, "loaded")
+      });
+      this._posthogBrowserClient = posthog;
+    } catch (e) {
+      logger.warn(`Failed to initialize PostHog browser telemetry: ${e}`);
+      this._posthogBrowserClient = null;
+    }
+  }
+  async _initPostHogNode() {
+    try {
+      const { PostHog } = await import("posthog-node");
+      const isServerlessEnvironment = [
+        "cloudflare-workers",
+        "edge",
+        "deno"
+      ].includes(this._runtimeEnvironment);
+      const posthogOptions = {
+        host: this.HOST,
+        disableGeoip: false
+      };
+      if (isServerlessEnvironment) {
+        posthogOptions.flushAt = 1;
+        posthogOptions.flushInterval = 0;
+      }
+      this._posthogNodeClient = new PostHog(
+        this.PROJECT_API_KEY,
+        posthogOptions
+      );
+      logger.debug("PostHog Node.js client initialized");
+    } catch (e) {
+      logger.warn(`Failed to initialize PostHog Node.js telemetry: ${e}`);
+      this._posthogNodeClient = null;
+    }
+  }
   /**
    * Get the detected runtime environment
    */
@@ -667,10 +722,9 @@ var Telemetry = class _Telemetry {
   }
   /**
    * Check if telemetry is enabled.
-   * Returns false if telemetry was disabled via environment variable or if not in Node.js environment.
    */
   get isEnabled() {
-    return this._posthogClient !== null || this._scarfClient !== null;
+    return this._posthogNodeClient !== null || this._posthogBrowserClient !== null || this._scarfClient !== null;
   }
   get userId() {
     if (this._currUserId) {
@@ -679,10 +733,10 @@ var Telemetry = class _Telemetry {
     try {
       switch (this._storageCapability) {
         case "filesystem":
-          this._currUserId = this.getUserIdFromFilesystem();
+          this._currUserId = this._getUserIdFromFilesystem();
           break;
         case "localStorage":
-          this._currUserId = this.getUserIdFromLocalStorage();
+          this._currUserId = this._getUserIdFromLocalStorage();
           break;
         case "session-only":
         default:
@@ -693,7 +747,7 @@ var Telemetry = class _Telemetry {
           break;
       }
       if (this._storageCapability === "filesystem" && this._currUserId) {
-        this.trackPackageDownloadInternal(this._currUserId, {
+        this._trackPackageDownloadInternal(this._currUserId, {
           triggered_by: "user_id_property"
         }).catch((e) => logger.debug(`Failed to track package download: ${e}`));
       }
@@ -706,22 +760,32 @@ var Telemetry = class _Telemetry {
   /**
    * Get or create user ID from filesystem (Node.js/Bun)
    */
-  getUserIdFromFilesystem() {
-    const isFirstTime = !fs.existsSync(this.USER_ID_PATH);
+  _getUserIdFromFilesystem() {
+    const fs = __require("fs");
+    const os = __require("os");
+    const path = __require("path");
+    if (!this._userIdPath) {
+      this._userIdPath = path.join(
+        this._getCacheHome(os, path),
+        "mcp_use_3",
+        "telemetry_user_id"
+      );
+    }
+    const isFirstTime = !fs.existsSync(this._userIdPath);
     if (isFirstTime) {
-      logger.debug(`Creating user ID path: ${this.USER_ID_PATH}`);
-      fs.mkdirSync(path.dirname(this.USER_ID_PATH), { recursive: true });
+      logger.debug(`Creating user ID path: ${this._userIdPath}`);
+      fs.mkdirSync(path.dirname(this._userIdPath), { recursive: true });
       const newUserId = generateUUID();
-      fs.writeFileSync(this.USER_ID_PATH, newUserId);
-      logger.debug(`User ID path created: ${this.USER_ID_PATH}`);
+      fs.writeFileSync(this._userIdPath, newUserId);
+      logger.debug(`User ID path created: ${this._userIdPath}`);
       return newUserId;
     }
-    return fs.readFileSync(this.USER_ID_PATH, "utf-8").trim();
+    return fs.readFileSync(this._userIdPath, "utf-8").trim();
   }
   /**
    * Get or create user ID from localStorage (Browser)
    */
-  getUserIdFromLocalStorage() {
+  _getUserIdFromLocalStorage() {
     try {
       let userId = localStorage.getItem(USER_ID_STORAGE_KEY);
       if (!userId) {
@@ -735,60 +799,89 @@ var Telemetry = class _Telemetry {
       return `session-${generateUUID()}`;
     }
   }
+  _getCacheHome(os, path) {
+    const envVar = process.env.XDG_CACHE_HOME;
+    if (envVar && path.isAbsolute(envVar)) {
+      return envVar;
+    }
+    const platform = process.platform;
+    const homeDir = os.homedir();
+    if (platform === "win32") {
+      const appdata = process.env.LOCALAPPDATA || process.env.APPDATA;
+      if (appdata) {
+        return appdata;
+      }
+      return path.join(homeDir, "AppData", "Local");
+    } else if (platform === "darwin") {
+      return path.join(homeDir, "Library", "Caches");
+    } else {
+      return path.join(homeDir, ".cache");
+    }
+  }
   async capture(event) {
-    logger.debug(
-      `CAPTURE: posthog: ${this._posthogClient !== null}, scarf: ${this._scarfClient !== null}`
-    );
-    if (!this._posthogClient && !this._scarfClient) {
+    if (this._posthogLoading) {
+      await this._posthogLoading;
+    }
+    if (!this._posthogNodeClient && !this._posthogBrowserClient && !this._scarfClient) {
       return;
     }
-    if (this._posthogClient) {
+    const properties = { ...event.properties };
+    properties.mcp_use_version = getPackageVersion();
+    properties.language = "typescript";
+    properties.source = this._source;
+    properties.runtime = this._runtimeEnvironment;
+    if (this._posthogNodeClient) {
       try {
-        const properties = { ...event.properties };
-        properties.mcp_use_version = getPackageVersion();
-        properties.language = "typescript";
-        properties.source = this._source;
-        properties.runtime = this._runtimeEnvironment;
-        logger.debug(`CAPTURE: PostHog Event ${event.name}`);
-        logger.debug(
-          `CAPTURE: PostHog Properties ${JSON.stringify(properties)}`
-        );
-        this._posthogClient.capture({
+        logger.debug(`CAPTURE: PostHog Node Event ${event.name}`);
+        this._posthogNodeClient.capture({
           distinctId: this.userId,
           event: event.name,
           properties
         });
       } catch (e) {
-        logger.debug(`Failed to track PostHog event ${event.name}: ${e}`);
+        logger.debug(`Failed to track PostHog Node event ${event.name}: ${e}`);
+      }
+    }
+    if (this._posthogBrowserClient) {
+      try {
+        logger.debug(`CAPTURE: PostHog Browser Event ${event.name}`);
+        this._posthogBrowserClient.capture(event.name, {
+          ...properties,
+          distinct_id: this.userId
+        });
+      } catch (e) {
+        logger.debug(
+          `Failed to track PostHog Browser event ${event.name}: ${e}`
+        );
       }
     }
     if (this._scarfClient) {
       try {
-        const properties = {};
-        properties.mcp_use_version = getPackageVersion();
-        properties.user_id = this.userId;
-        properties.event = event.name;
-        properties.language = "typescript";
-        properties.source = this._source;
-        properties.runtime = this._runtimeEnvironment;
-        await this._scarfClient.logEvent(properties);
+        const scarfProperties = {
+          ...properties,
+          user_id: this.userId,
+          event: event.name
+        };
+        await this._scarfClient.logEvent(scarfProperties);
       } catch (e) {
         logger.debug(`Failed to track Scarf event ${event.name}: ${e}`);
       }
     }
   }
+  // ============================================================================
+  // Package Download Tracking (Node.js only)
+  // ============================================================================
   /**
    * Track package download event.
    * This is a public wrapper that safely accesses userId.
    */
   async trackPackageDownload(properties) {
-    return this.trackPackageDownloadInternal(this.userId, properties);
+    return this._trackPackageDownloadInternal(this.userId, properties);
   }
   /**
    * Internal method to track package download with explicit userId.
-   * This avoids circular dependency when called from the userId getter.
    */
-  async trackPackageDownloadInternal(userId, properties) {
+  async _trackPackageDownloadInternal(userId, properties) {
     if (!this._scarfClient) {
       return;
     }
@@ -796,22 +889,32 @@ var Telemetry = class _Telemetry {
       return;
     }
     try {
+      const fs = __require("fs");
+      const path = __require("path");
+      const os = __require("os");
+      if (!this._versionDownloadPath) {
+        this._versionDownloadPath = path.join(
+          this._getCacheHome(os, path),
+          "mcp_use",
+          "download_version"
+        );
+      }
       const currentVersion = getPackageVersion();
       let shouldTrack = false;
       let firstDownload = false;
-      if (!fs.existsSync(this.VERSION_DOWNLOAD_PATH)) {
+      if (!fs.existsSync(this._versionDownloadPath)) {
         shouldTrack = true;
         firstDownload = true;
-        fs.mkdirSync(path.dirname(this.VERSION_DOWNLOAD_PATH), {
+        fs.mkdirSync(path.dirname(this._versionDownloadPath), {
           recursive: true
         });
-        fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
+        fs.writeFileSync(this._versionDownloadPath, currentVersion);
       } else {
-        const savedVersion = fs.readFileSync(this.VERSION_DOWNLOAD_PATH, "utf-8").trim();
+        const savedVersion = fs.readFileSync(this._versionDownloadPath, "utf-8").trim();
         if (currentVersion > savedVersion) {
           shouldTrack = true;
           firstDownload = false;
-          fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
+          fs.writeFileSync(this._versionDownloadPath, currentVersion);
         }
       }
       if (shouldTrack) {
@@ -845,9 +948,6 @@ var Telemetry = class _Telemetry {
   // ============================================================================
   /**
    * Track server run event directly from an MCPServer instance.
-   * This extracts the necessary data from the server and creates the event.
-   * @param server - The MCPServer instance (or any object conforming to MCPServerTelemetryInfo)
-   * @param transport - The transport type (e.g., "http", "stdio", "supabase")
    */
   async trackServerRunFromServer(server, transport) {
     if (!this.isEnabled) return;
@@ -893,37 +993,123 @@ var Telemetry = class _Telemetry {
     const event = new ConnectorInitEvent(data);
     await this.capture(event);
   }
+  async trackClientAddServer(serverName, serverConfig) {
+    if (!this.isEnabled) return;
+    const event = new ClientAddServerEvent({ serverName, serverConfig });
+    await this.capture(event);
+  }
+  async trackClientRemoveServer(serverName) {
+    if (!this.isEnabled) return;
+    const event = new ClientRemoveServerEvent({ serverName });
+    await this.capture(event);
+  }
+  // ============================================================================
+  // React Hook / Browser specific events
+  // ============================================================================
+  async trackUseMcpConnection(data) {
+    if (!this.isEnabled) return;
+    await this.capture({
+      name: "usemcp_connection",
+      properties: {
+        url_domain: new URL(data.url).hostname,
+        // Only domain for privacy
+        transport_type: data.transportType,
+        success: data.success,
+        error_type: data.errorType ?? null,
+        connection_time_ms: data.connectionTimeMs ?? null,
+        has_oauth: data.hasOAuth,
+        has_sampling: data.hasSampling,
+        has_elicitation: data.hasElicitation
+      }
+    });
+  }
+  async trackUseMcpToolCall(data) {
+    if (!this.isEnabled) return;
+    await this.capture({
+      name: "usemcp_tool_call",
+      properties: {
+        tool_name: data.toolName,
+        success: data.success,
+        error_type: data.errorType ?? null,
+        execution_time_ms: data.executionTimeMs ?? null
+      }
+    });
+  }
+  async trackUseMcpResourceRead(data) {
+    if (!this.isEnabled) return;
+    await this.capture({
+      name: "usemcp_resource_read",
+      properties: {
+        resource_uri_scheme: data.resourceUri.split(":")[0],
+        // Only scheme for privacy
+        success: data.success,
+        error_type: data.errorType ?? null
+      }
+    });
+  }
+  // ============================================================================
+  // Browser-specific Methods
+  // ============================================================================
+  /**
+   * Identify the current user (useful for linking sessions)
+   * Browser only - no-op in Node.js
+   */
+  identify(userId, properties) {
+    if (this._posthogBrowserClient) {
+      try {
+        this._posthogBrowserClient.identify(userId, properties);
+      } catch (e) {
+        logger.debug(`Failed to identify user: ${e}`);
+      }
+    }
+  }
+  /**
+   * Reset the user identity (useful for logout)
+   * Browser only - no-op in Node.js
+   */
+  reset() {
+    if (this._posthogBrowserClient) {
+      try {
+        this._posthogBrowserClient.reset();
+      } catch (e) {
+        logger.debug(`Failed to reset user: ${e}`);
+      }
+    }
+    this._currUserId = null;
+  }
+  // ============================================================================
+  // Node.js-specific Methods
+  // ============================================================================
+  /**
+   * Flush the telemetry queue (Node.js only)
+   */
   flush() {
-    if (this._posthogClient) {
+    if (this._posthogNodeClient) {
       try {
-        this._posthogClient.flush();
+        this._posthogNodeClient.flush();
         logger.debug("PostHog client telemetry queue flushed");
       } catch (e) {
         logger.debug(`Failed to flush PostHog client: ${e}`);
       }
     }
-    if (this._scarfClient) {
-      logger.debug("Scarf telemetry events sent immediately (no flush needed)");
-    }
   }
+  /**
+   * Shutdown the telemetry client (Node.js only)
+   */
   shutdown() {
-    if (this._posthogClient) {
+    if (this._posthogNodeClient) {
       try {
-        this._posthogClient.shutdown();
+        this._posthogNodeClient.shutdown();
         logger.debug("PostHog client shutdown successfully");
       } catch (e) {
         logger.debug(`Error shutting down PostHog client: ${e}`);
       }
     }
-    if (this._scarfClient) {
-      logger.debug("Scarf telemetry client shutdown (no action needed)");
-    }
   }
 };
-
-// src/telemetry/index.ts
+var Tel = Telemetry;
 function setTelemetrySource(source) {
-  Telemetry.getInstance().setSource(source);
+  Tel.getInstance().setSource(source);
 }
 __name(setTelemetrySource, "setTelemetrySource");
 
@@ -938,5 +1124,6 @@ export {
   getPackageVersion,
   extractModelInfo,
   Telemetry,
+  Tel,
   setTelemetrySource
 };