mcp-use/dist/src/server/index.cjs

Opinionated MCP Framework for TypeScript (@modelcontextprotocol/sdk compatible) - Build MCP Agents, Clients and Servers with support for ChatGPT Apps, Code Mode, OAuth, Notifications, Sampling, Observability and more.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/telemetry/events.ts
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
  };
}
var BaseTelemetryEvent, MCPAgentExecutionEvent, ServerRunEvent, ServerInitializeEvent, ServerToolCallEvent, ServerResourceCallEvent, ServerPromptCallEvent, ServerContextEvent, MCPClientInitEvent, ConnectorInitEvent, ClientAddServerEvent, ClientRemoveServerEvent;
var init_events = __esm({
  "src/telemetry/events.ts"() {
    "use strict";
    BaseTelemetryEvent = class {
      static {
        __name(this, "BaseTelemetryEvent");
      }
    };
    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
        };
      }
    };
    __name(createServerRunEventData, "createServerRunEventData");
    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
        };
      }
    };
    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
        };
      }
    };
    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
        };
      }
    };
    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
        };
      }
    };
    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, "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;
        }
      }
    };
    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/version.ts
function getPackageVersion() {
  return VERSION;
}
var VERSION;
var init_version = __esm({
  "src/version.ts"() {
    "use strict";
    VERSION = "1.12.2";
    __name(getPackageVersion, "getPackageVersion");
  }
});

// src/telemetry/utils.ts
var init_utils = __esm({
  "src/telemetry/utils.ts"() {
    "use strict";
    init_version();
  }
});

// src/logging.ts
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";
  }
}
function formatArgs(args) {
  if (args.length === 0) return "";
  return args.map((arg) => {
    if (typeof arg === "string") return arg;
    try {
      return JSON.stringify(arg);
    } catch {
      return String(arg);
    }
  }).join(" ");
}
var DEFAULT_LOGGER_NAME, SimpleConsoleLogger, Logger, logger;
var init_logging = __esm({
  "src/logging.ts"() {
    "use strict";
    DEFAULT_LOGGER_NAME = "mcp-use";
    __name(resolveLevel, "resolveLevel");
    __name(formatArgs, "formatArgs");
    SimpleConsoleLogger = class {
      static {
        __name(this, "SimpleConsoleLogger");
      }
      _level;
      name;
      format;
      constructor(name = DEFAULT_LOGGER_NAME, level = "info", format = "minimal") {
        this.name = name;
        this._level = level;
        this.format = format;
      }
      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, args) {
        const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
        const extraArgs = formatArgs(args);
        const fullMessage = extraArgs ? `${message} ${extraArgs}` : message;
        switch (this.format) {
          case "detailed":
            return `${timestamp} [${this.name}] ${level.toUpperCase()}: ${fullMessage}`;
          case "emoji": {
            const emojiMap = {
              error: "\u274C",
              warn: "\u26A0\uFE0F",
              info: "\u2139\uFE0F",
              http: "\u{1F310}",
              verbose: "\u{1F4DD}",
              debug: "\u{1F50D}",
              silly: "\u{1F92A}"
            };
            return `${timestamp} [${this.name}] ${emojiMap[level] || ""} ${level.toUpperCase()}: ${fullMessage}`;
          }
          case "minimal":
          default:
            return `${timestamp} [${this.name}] ${level}: ${fullMessage}`;
        }
      }
      error(message, ...args) {
        if (this.shouldLog("error")) {
          console.error(this.formatMessage("error", message, args));
        }
      }
      warn(message, ...args) {
        if (this.shouldLog("warn")) {
          console.warn(this.formatMessage("warn", message, args));
        }
      }
      info(message, ...args) {
        if (this.shouldLog("info")) {
          console.info(this.formatMessage("info", message, args));
        }
      }
      debug(message, ...args) {
        if (this.shouldLog("debug")) {
          console.debug(this.formatMessage("debug", message, args));
        }
      }
      http(message, ...args) {
        if (this.shouldLog("http")) {
          console.log(this.formatMessage("http", message, args));
        }
      }
      verbose(message, ...args) {
        if (this.shouldLog("verbose")) {
          console.log(this.formatMessage("verbose", message, args));
        }
      }
      silly(message, ...args) {
        if (this.shouldLog("silly")) {
          console.log(this.formatMessage("silly", message, args));
        }
      }
      get level() {
        return this._level;
      }
      set level(newLevel) {
        this._level = newLevel;
      }
      setFormat(format) {
        this.format = format;
      }
    };
    Logger = class {
      static {
        __name(this, "Logger");
      }
      static instances = {};
      static currentFormat = "minimal";
      static get(name = DEFAULT_LOGGER_NAME) {
        if (!this.instances[name]) {
          const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || void 0;
          this.instances[name] = new SimpleConsoleLogger(
            name,
            resolveLevel(debugEnv),
            this.currentFormat
          );
        }
        return this.instances[name];
      }
      static configure(options = {}) {
        const { level, format = "minimal" } = options;
        const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || void 0;
        const resolvedLevel = level ?? resolveLevel(debugEnv);
        this.currentFormat = format;
        Object.values(this.instances).forEach((logger3) => {
          logger3.level = resolvedLevel;
          logger3.setFormat(format);
        });
      }
      static setDebug(enabled) {
        let level;
        if (enabled === 2 || enabled === true) level = "debug";
        else if (enabled === 1) level = "info";
        else level = "info";
        Object.values(this.instances).forEach((logger3) => {
          logger3.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 });
      }
    };
    logger = Logger.get();
  }
});

// src/telemetry/telemetry-browser.ts
function generateUUID() {
  if (typeof globalThis !== "undefined" && globalThis.crypto && typeof globalThis.crypto.randomUUID === "function") {
    return globalThis.crypto.randomUUID();
  }
  if (typeof globalThis !== "undefined" && globalThis.crypto && typeof globalThis.crypto.getRandomValues === "function") {
    const array2 = new Uint8Array(16);
    globalThis.crypto.getRandomValues(array2);
    const hex = Array.from(array2, (v) => v.toString(16).padStart(2, "0")).join(
      ""
    );
    return `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}`;
  }
  return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}-${Math.random().toString(36).substring(2, 15)}`;
}
function secureRandomString() {
  if (typeof window !== "undefined" && window.crypto && typeof window.crypto.getRandomValues === "function") {
    const array2 = new Uint8Array(8);
    window.crypto.getRandomValues(array2);
    return Array.from(array2, (v) => v.toString(16).padStart(2, "0")).join("");
  }
  if (typeof globalThis !== "undefined" && globalThis.crypto && typeof globalThis.crypto.getRandomValues === "function") {
    const array2 = new Uint8Array(8);
    globalThis.crypto.getRandomValues(array2);
    return Array.from(array2, (v) => v.toString(16).padStart(2, "0")).join("");
  }
  return Math.random().toString(36).substring(2, 15);
}
function detectRuntimeEnvironment() {
  try {
    if (typeof window !== "undefined" && typeof document !== "undefined") {
      return "browser";
    }
    return "unknown";
  } catch {
    return "unknown";
  }
}
function getStorageCapability(env) {
  if (env === "browser") {
    try {
      if (typeof localStorage !== "undefined") {
        localStorage.setItem("__mcp_use_test__", "1");
        localStorage.removeItem("__mcp_use_test__");
        return "localStorage";
      }
    } catch {
    }
  }
  return "session-only";
}
function getRuntimeEnvironment() {
  if (cachedEnvironment === null) {
    cachedEnvironment = detectRuntimeEnvironment();
  }
  return cachedEnvironment;
}
var USER_ID_STORAGE_KEY, cachedEnvironment, Telemetry;
var init_telemetry_browser = __esm({
  "src/telemetry/telemetry-browser.ts"() {
    "use strict";
    init_logging();
    init_events();
    init_utils();
    __name(generateUUID, "generateUUID");
    __name(secureRandomString, "secureRandomString");
    USER_ID_STORAGE_KEY = "mcp_use_user_id";
    __name(detectRuntimeEnvironment, "detectRuntimeEnvironment");
    __name(getStorageCapability, "getStorageCapability");
    cachedEnvironment = null;
    __name(getRuntimeEnvironment, "getRuntimeEnvironment");
    Telemetry = class _Telemetry {
      static {
        __name(this, "Telemetry");
      }
      static instance = null;
      PROJECT_API_KEY = "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI";
      HOST = "https://eu.i.posthog.com";
      UNKNOWN_USER_ID = "UNKNOWN_USER_ID";
      _currUserId = null;
      _posthogBrowserClient = null;
      _posthogLoading = null;
      _runtimeEnvironment;
      _storageCapability;
      _source;
      constructor() {
        this._runtimeEnvironment = getRuntimeEnvironment();
        this._storageCapability = getStorageCapability(this._runtimeEnvironment);
        this._source = this._getSourceFromLocalStorage() || this._runtimeEnvironment;
        const telemetryDisabled = this._checkTelemetryDisabled();
        const canSupportTelemetry = this._runtimeEnvironment !== "unknown";
        if (telemetryDisabled) {
          this._posthogBrowserClient = null;
          logger.debug("Telemetry disabled via localStorage");
        } else if (!canSupportTelemetry) {
          this._posthogBrowserClient = null;
          logger.debug(
            `Telemetry disabled - unknown environment: ${this._runtimeEnvironment}`
          );
        } else {
          logger.info(
            "Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false in localStorage to disable."
          );
          this._posthogLoading = this._initPostHogBrowser();
        }
      }
      _getSourceFromLocalStorage() {
        try {
          if (typeof localStorage !== "undefined") {
            return localStorage.getItem("MCP_USE_TELEMETRY_SOURCE");
          }
        } catch {
        }
        return null;
      }
      _checkTelemetryDisabled() {
        if (typeof localStorage !== "undefined" && localStorage.getItem("MCP_USE_ANONYMIZED_TELEMETRY") === "false") {
          return true;
        }
        return false;
      }
      async _initPostHogBrowser() {
        try {
          const posthogModule = await import("posthog-js");
          const posthogModuleTyped = posthogModule;
          const posthog = posthogModuleTyped.default || posthogModuleTyped.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;
        }
      }
      /**
       * 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;
        try {
          if (typeof localStorage !== "undefined") {
            localStorage.setItem("MCP_USE_TELEMETRY_SOURCE", source);
          }
        } catch {
        }
        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._posthogBrowserClient !== null;
      }
      get userId() {
        if (this._currUserId) {
          return this._currUserId;
        }
        try {
          switch (this._storageCapability) {
            case "localStorage":
              this._currUserId = this._getUserIdFromLocalStorage();
              break;
            case "session-only":
            default:
              try {
                this._currUserId = `session-${generateUUID()}`;
              } catch (uuidError) {
                this._currUserId = `session-${Date.now()}-${secureRandomString()}`;
              }
              break;
          }
        } catch (e) {
          this._currUserId = this.UNKNOWN_USER_ID;
        }
        return this._currUserId;
      }
      /**
       * Get or create user ID from localStorage (Browser)
       */
      _getUserIdFromLocalStorage() {
        try {
          if (typeof localStorage === "undefined") {
            throw new Error("localStorage is not available");
          }
          try {
            localStorage.setItem("__mcp_use_test__", "1");
            localStorage.removeItem("__mcp_use_test__");
          } catch (testError) {
            throw new Error(`localStorage is not writable: ${testError}`);
          }
          let userId = localStorage.getItem(USER_ID_STORAGE_KEY);
          if (!userId) {
            try {
              userId = generateUUID();
            } catch (uuidError) {
              userId = `${Date.now()}-${secureRandomString()}`;
            }
            localStorage.setItem(USER_ID_STORAGE_KEY, userId);
          }
          return userId;
        } catch (e) {
          logger.debug(`Failed to access localStorage for user ID: ${e}`);
          let sessionId;
          try {
            sessionId = `session-${generateUUID()}`;
          } catch (uuidError) {
            sessionId = `session-${Date.now()}-${secureRandomString()}`;
          }
          return sessionId;
        }
      }
      async capture(event) {
        if (this._posthogLoading) {
          await this._posthogLoading;
        }
        if (!this._posthogBrowserClient) {
          return;
        }
        const currentUserId = this.userId;
        const properties = { ...event.properties };
        properties.mcp_use_version = getPackageVersion();
        properties.language = "typescript";
        properties.source = this._source;
        properties.runtime = this._runtimeEnvironment;
        if (this._posthogBrowserClient) {
          try {
            this._posthogBrowserClient.capture(event.name, {
              ...properties,
              distinct_id: currentUserId
            });
          } catch (e) {
            logger.debug(
              `Failed to track PostHog Browser event ${event.name}: ${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
       */
      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
       */
      reset() {
        if (this._posthogBrowserClient) {
          try {
            this._posthogBrowserClient.reset();
          } catch (e) {
            logger.debug(`Failed to reset user: ${e}`);
          }
        }
        this._currUserId = null;
      }
      // ============================================================================
      // Node.js-specific Methods (no-ops in browser)
      // ============================================================================
      /**
       * Flush the telemetry queue (Node.js only - no-op in browser)
       */
      flush() {
      }
      /**
       * Shutdown the telemetry client (Node.js only - no-op in browser)
       */
      shutdown() {
      }
      /**
       * Track package download event (Node.js only - no-op in browser)
       */
      async trackPackageDownload(properties) {
      }
    };
  }
});

// src/telemetry/index.ts
var init_telemetry = __esm({
  "src/telemetry/index.ts"() {
    "use strict";
    init_events();
    init_utils();
    init_telemetry_browser();
  }
});

// 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 generateUUID2() {
  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: readFileSync2 } = await import("fs");
        const result = readFileSync2(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: readFileSync2 } = await import("fs");
        const buffer = readFileSync2(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: existsSync2 } = await import("fs");
        return existsSync2(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(generateUUID2, "generateUUID");
  }
});

// src/server/prompts/conversion.ts
var conversion_exports = {};
__export(conversion_exports, {
  convertToolResultToPromptResult: () => convertToolResultToPromptResult
});
function isGetPromptResult(result) {
  return "messages" in result && Array.isArray(result.messages);
}
function convertToolResultToPromptResult(result) {
  if (isGetPromptResult(result)) {
    return result;
  }
  const messages = [];
  if (result.content && result.content.length > 0) {
    for (const content of result.content) {
      if (content.type === "text") {
        const textContent = content;
        messages.push({
          role: "user",
          content: {
            type: "text",
            text: textContent.text
          }
        });
      } else if (content.type === "image") {
        const imageContent = content;
        messages.push({
          role: "user",
          content: {
            type: "image",
            data: imageContent.data,
            mimeType: imageContent.mimeType || "image/png"
          }
        });
      } else if (content.type === "resource") {
        const resourceContent = content;
        const resourceData = resourceContent.resource;
        const embeddedResource = {
          type: "resource",
          resource: {
            uri: resourceData.uri,
            mimeType: resourceData.mimeType
          }
        };
        if (resourceData.text) {
          embeddedResource.resource.text = resourceData.text;
        } else if (resourceData.blob) {
          embeddedResource.resource.blob = resourceData.blob;
        }
        messages.push({
          role: "user",
          content: embeddedResource
        });
      }
    }
  }
  if (messages.length === 0) {
    messages.push({
      role: "user",
      content: {
        type: "text",
        text: ""
      }
    });
  }
  return {
    messages,
    description: result._meta?.description
  };
}
var init_conversion = __esm({
  "src/server/prompts/conversion.ts"() {
    "use strict";
    __name(isGetPromptResult, "isGetPromptResult");
    __name(convertToolResultToPromptResult, "convertToolResultToPromptResult");
  }
});

// src/server/context-storage.ts
var context_storage_exports = {};
__export(context_storage_exports, {
  getRequestContext: () => getRequestContext,
  getSessionId: () => getSessionId,
  hasRequestContext: () => hasRequestContext,
  runWithContext: () => runWithContext
});
async function runWithContext(context, fn, sessionId) {
  return requestContextStorage.run({ honoContext: context, sessionId }, fn);
}
function getRequestContext() {
  return requestContextStorage.getStore()?.honoContext;
}
function getSessionId() {
  return requestContextStorage.getStore()?.sessionId;
}
function hasRequestContext() {
  return requestContextStorage.getStore() !== void 0;
}
var import_node_async_hooks, requestContextStorage;
var init_context_storage = __esm({
  "src/server/context-storage.ts"() {
    "use strict";
    import_node_async_hooks = require("async_hooks");
    requestContextStorage = new import_node_async_hooks.AsyncLocalStorage();
    __name(runWithContext, "runWithContext");
    __name(getRequestContext, "getRequestContext");
    __name(getSessionId, "getSessionId");
    __name(hasRequestContext, "hasRequestContext");
  }
});

// src/errors.ts
var ElicitationValidationError;
var init_errors = __esm({
  "src/errors.ts"() {
    "use strict";
    ElicitationValidationError = class _ElicitationValidationError extends Error {
      constructor(message, cause) {
        super(message);
        this.cause = cause;
        this.name = "ElicitationValidationError";
        if (Error.captureStackTrace) {
          Error.captureStackTrace(this, _ElicitationValidationError);
        }
      }
      static {
        __name(this, "ElicitationValidationError");
      }
    };
  }
});

// src/server/tools/tool-execution-helpers.ts
var tool_execution_helpers_exports = {};
__export(tool_execution_helpers_exports, {
  VALID_LOG_LEVELS: () => VALID_LOG_LEVELS,
  createElicitMethod: () => createElicitMethod,
  createEnhancedContext: () => createEnhancedContext,
  createReportProgressMethod: () => createReportProgressMethod,
  createSampleMethod: () => createSampleMethod,
  findSessionContext: () => findSessionContext,
  isValidLogLevel: () => isValidLogLevel,
  parseElicitParams: () => parseElicitParams,
  sendProgressNotification: () => sendProgressNotification,
  shouldLogMessage: () => shouldLogMessage,
  withTimeout: () => withTimeout
});
function findSessionContext(sessions, initialRequestContext, extraProgressToken, extraSendNotification) {
  let requestContext = initialRequestContext;
  let session;
  let progressToken = extraProgressToken;
  let sendNotification2 = extraSendNotification;
  if (!requestContext) {
    for (const [, s] of sessions.entries()) {
      if (s.context) {
        requestContext = s.context;
        break;
      }
    }
  }
  if (!progressToken || !sendNotification2) {
    if (requestContext) {
      for (const [, s] of sessions.entries()) {
        if (s.context === requestContext) {
          session = s;
          break;
        }
      }
    } else {
      const firstSession = sessions.values().next().value;
      if (firstSession) {
        session = firstSession;
      }
    }
    if (session) {
      if (!progressToken && session.progressToken) {
        progressToken = session.progressToken;
      }
      if (!sendNotification2 && session.sendNotification) {
        sendNotification2 = session.sendNotification;
      }
    }
  }
  return { requestContext, session, progressToken, sendNotification: sendNotification2 };
}
async function sendProgressNotification(sendNotification2, progressToken, progress, total, message) {
  if (sendNotification2 && progressToken !== void 0) {
    try {
      await sendNotification2({
        method: "notifications/progress",
        params: {
          progressToken,
          progress,
          total,
          message
        }
      });
    } catch {
    }
  }
}
async function withTimeout(promise, timeout, errorMessage) {
  if (timeout && timeout !== Infinity) {
    const timeoutPromise = new Promise((_, reject) => {
      setTimeout(() => reject(new Error(errorMessage)), timeout);
    });
    return await Promise.race([promise, timeoutPromise]);
  }
  return await promise;
}
function parseElicitParams(messageOrParams, schemaOrUrlOrOptions, maybeOptions) {
  let sdkParams;
  let zodSchema = null;
  let options;
  if (typeof messageOrParams === "string") {
    const message = messageOrParams;
    if (typeof schemaOrUrlOrOptions === "string") {
      options = maybeOptions;
      const elicitationId = `elicit-${generateUUID2()}`;
      sdkParams = {
        mode: "url",
        message,
        url: schemaOrUrlOrOptions,
        elicitationId
      };
    } else if (schemaOrUrlOrOptions && typeof schemaOrUrlOrOptions === "object" && "_def" in schemaOrUrlOrOptions) {
      options = maybeOptions;
      zodSchema = schemaOrUrlOrOptions;
      const jsonSchema = (0, import_zod_json_schema_compat.toJsonSchemaCompat)(schemaOrUrlOrOptions);
      sdkParams = {
        mode: "form",
        message,
        requestedSchema: jsonSchema
      };
    } else {
      throw new Error(
        "Invalid elicit signature: second parameter must be a Zod schema or URL string"
      );
    }
  } else {
    options = schemaOrUrlOrOptions;
    const params = messageOrParams;
    if (params.mode === "url") {
      const elicitationId = `elicit-${generateUUID2()}`;
      sdkParams = {
        mode: "url",
        message: params.message,
        url: params.url,
        elicitationId
      };
    } else {
      sdkParams = {
        mode: "form",
        message: params.message,
        requestedSchema: params.requestedSchema
      };
    }
  }
  return { sdkParams, zodSchema, options };
}
function createSampleMethod(createMessage, progressToken, sendNotification2) {
  return async (promptOrParams, options) => {
    let sampleParams;
    if (typeof promptOrParams === "string") {
      sampleParams = {
        messages: [
          {
            role: "user",
            content: {
              type: "text",
              text: promptOrParams
            }
          }
        ],
        maxTokens: options?.maxTokens || 1e3,
        ...options?.modelPreferences && {
          modelPreferences: options.modelPreferences
        },
        ...options?.systemPrompt && { systemPrompt: options.systemPrompt },
        ...options?.temperature !== void 0 && {
          temperature: options.temperature
        },
        ...options?.stopSequences && { stopSequences: options.stopSequences },
        ...options?.metadata && { metadata: options.metadata }
      };
    } else {
      sampleParams = promptOrParams;
    }
    const { timeout, progressIntervalMs = 5e3, onProgress } = options ?? {};
    let progressCount = 0;
    let completed = false;
    let progressInterval = null;
    if (progressToken !== void 0 && sendNotification2) {
      progressInterval = setInterval(async () => {
        if (completed) return;
        progressCount++;
        const progressData = {
          progress: progressCount,
          total: void 0,
          message: `Waiting for LLM response... (${progressCount * Math.round(progressIntervalMs / 1e3)}s elapsed)`
        };
        if (onProgress) {
          try {
            onProgress(progressData);
          } catch {
          }
        }
        await sendProgressNotification(
          sendNotification2,
          progressToken,
          progressData.progress,
          progressData.total,
          progressData.message
        );
      }, progressIntervalMs);
    }
    try {
      console.log("[SAMPLING DEBUG] Calling createMessage...");
      const sdkTimeout = timeout && timeout !== Infinity ? timeout : 2147483647;
      const samplePromise = createMessage(sampleParams, {
        timeout: sdkTimeout
      });
      console.log("[SAMPLING DEBUG] Waiting for response...");
      const result = await withTimeout(
        samplePromise,
        timeout,
        `Sampling timed out after ${timeout}ms`
      );
      console.log("[SAMPLING DEBUG] Got result:", result);
      Telemetry.getInstance().trackServerContext({
        contextType: "sample"
      }).catch((e) => console.debug(`Failed to track sample context: ${e}`));
      return result;
    } catch (error2) {
      console.error("[SAMPLING DEBUG] Error during sampling:", error2);
      throw error2;
    } finally {
      completed = true;
      if (progressInterval) {
        clearInterval(progressInterval);
      }
    }
  };
}
function createElicitMethod(elicitInput) {
  return async (messageOrParams, schemaOrUrlOrOptions, maybeOptions) => {
    const { sdkParams, zodSchema, options } = parseElicitParams(
      messageOrParams,
      schemaOrUrlOrOptions,
      maybeOptions
    );
    const { timeout } = options ?? {};
    const sdkTimeout = timeout && timeout !== Infinity ? timeout : 2147483647;
    const result = await elicitInput(sdkParams, { timeout: sdkTimeout });
    Telemetry.getInstance().trackServerContext({
      contextType: "elicit"
    }).catch((e) => console.debug(`Failed to track elicit context: ${e}`));
    if (zodSchema && result.action === "accept" && result.data) {
      try {
        const validatedData = zodSchema.parse(result.data);
        return {
          ...result,
          data: validatedData
        };
      } catch (error2) {
        const err = error2;
        throw new ElicitationValidationError(
          `Elicitation data validation failed: ${err.message}`,
          err
        );
      }
    }
    return result;
  };
}
function createReportProgressMethod(progressToken, sendNotification2) {
  if (progressToken !== void 0 && sendNotification2) {
    return async (progress, total, message) => {
      await sendProgressNotification(