mcp-use 1.9.1-canary.0 → 1.10.0-canary.10

package/dist/src/server/index.cjs

@@ -55,48 +55,48 @@ var init_runtime = __esm({
     __name(getEnv, "getEnv");
     __name(getCwd, "getCwd");
     fsHelpers = {
-      async readFileSync(path, encoding = "utf8") {
+      async readFileSync(path2, encoding = "utf8") {
         if (isDeno) {
-          return await globalThis.Deno.readTextFile(path);
+          return await globalThis.Deno.readTextFile(path2);
         }
-        const { readFileSync } = await import("fs");
-        const result = readFileSync(path, encoding);
+        const { readFileSync: readFileSync2 } = await import("fs");
+        const result = readFileSync2(path2, encoding);
         return typeof result === "string" ? result : result.toString(encoding);
       },
-      async readFile(path) {
+      async readFile(path2) {
         if (isDeno) {
-          const data = await globalThis.Deno.readFile(path);
+          const data = await globalThis.Deno.readFile(path2);
           return data.buffer;
         }
-        const { readFileSync } = await import("fs");
-        const buffer = readFileSync(path);
+        const { readFileSync: readFileSync2 } = await import("fs");
+        const buffer = readFileSync2(path2);
         return buffer.buffer.slice(
           buffer.byteOffset,
           buffer.byteOffset + buffer.byteLength
         );
       },
-      async existsSync(path) {
+      async existsSync(path2) {
         if (isDeno) {
           try {
-            await globalThis.Deno.stat(path);
+            await globalThis.Deno.stat(path2);
             return true;
           } catch {
             return false;
           }
         }
-        const { existsSync } = await import("fs");
-        return existsSync(path);
+        const { existsSync: existsSync2 } = await import("fs");
+        return existsSync2(path2);
       },
-      async readdirSync(path) {
+      async readdirSync(path2) {
         if (isDeno) {
           const entries = [];
-          for await (const entry of globalThis.Deno.readDir(path)) {
+          for await (const entry of globalThis.Deno.readDir(path2)) {
             entries.push(entry.name);
           }
           return entries;
         }
         const { readdirSync } = await import("fs");
-        return readdirSync(path);
+        return readdirSync(path2);
       }
     };
     pathHelpers = {
@@ -122,18 +122,1137 @@ var init_runtime = __esm({
   }
 });
 
+// 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());
+  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;
+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
+        };
+      }
+    };
+    ConnectorInitEvent = class extends BaseTelemetryEvent {
+      constructor(data) {
+        super();
+        this.data = data;
+      }
+      static {
+        __name(this, "ConnectorInitEvent");
+      }
+      get name() {
+        return "connector_init";
+      }
+      get properties() {
+        return {
+          connector_type: this.data.connectorType,
+          server_command: this.data.serverCommand ?? null,
+          server_args: this.data.serverArgs ?? null,
+          server_url: this.data.serverUrl ?? null,
+          public_identifier: this.data.publicIdentifier ?? null
+        };
+      }
+    };
+  }
+});
+
+// src/version.ts
+function getPackageVersion() {
+  return VERSION;
+}
+var VERSION;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    VERSION = "1.10.0-canary.10";
+    __name(getPackageVersion, "getPackageVersion");
+  }
+});
+
+// src/telemetry/utils.ts
+var init_utils = __esm({
+  "src/telemetry/utils.ts"() {
+    "use strict";
+    init_version();
+  }
+});
+
+// src/telemetry/telemetry.ts
+function detectRuntimeEnvironment() {
+  try {
+    if (typeof globalThis.Bun !== "undefined") {
+      return "bun";
+    }
+    if (typeof globalThis.Deno !== "undefined") {
+      return "deno";
+    }
+    if (typeof navigator !== "undefined" && navigator.userAgent?.includes("Cloudflare-Workers")) {
+      return "cloudflare-workers";
+    }
+    if (typeof globalThis.EdgeRuntime !== "undefined") {
+      return "edge";
+    }
+    if (typeof process !== "undefined" && typeof process.versions?.node !== "undefined" && typeof fs !== "undefined" && typeof fs.existsSync === "function") {
+      return "node";
+    }
+    if (typeof window !== "undefined" && typeof document !== "undefined") {
+      return "browser";
+    }
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function getStorageCapability(env) {
+  switch (env) {
+    case "node":
+    case "bun":
+      return "filesystem";
+    case "browser":
+      try {
+        if (typeof localStorage !== "undefined") {
+          localStorage.setItem("__mcp_use_test__", "1");
+          localStorage.removeItem("__mcp_use_test__");
+          return "localStorage";
+        }
+      } catch {
+      }
+      return "session-only";
+    case "deno":
+      return "session-only";
+    default:
+      return "session-only";
+  }
+}
+function getRuntimeEnvironment() {
+  if (cachedEnvironment === null) {
+    cachedEnvironment = detectRuntimeEnvironment();
+  }
+  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 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();
+    init_utils();
+    USER_ID_STORAGE_KEY = "mcp_use_user_id";
+    __name(detectRuntimeEnvironment, "detectRuntimeEnvironment");
+    __name(getStorageCapability, "getStorageCapability");
+    cachedEnvironment = null;
+    __name(getRuntimeEnvironment, "getRuntimeEnvironment");
+    __name(isNodeJSEnvironment2, "isNodeJSEnvironment");
+    ScarfEventLogger = class {
+      static {
+        __name(this, "ScarfEventLogger");
+      }
+      endpoint;
+      timeout;
+      constructor(endpoint, timeout = 3e3) {
+        this.endpoint = endpoint;
+        this.timeout = timeout;
+      }
+      async logEvent(properties) {
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+          const response = await fetch(this.endpoint, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify(properties),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+          }
+        } catch (error2) {
+          logger.debug(`Failed to send Scarf event: ${error2}`);
+        }
+      }
+    };
+    __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;
+      _scarfClient = null;
+      _runtimeEnvironment;
+      _storageCapability;
+      _source;
+      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 canSupportTelemetry = this._runtimeEnvironment !== "unknown";
+        const isServerlessEnvironment = [
+          "cloudflare-workers",
+          "edge",
+          "deno"
+        ].includes(this._runtimeEnvironment);
+        if (telemetryDisabled) {
+          this._posthogClient = null;
+          this._scarfClient = null;
+          logger.debug("Telemetry disabled via environment variable");
+        } else if (!canSupportTelemetry) {
+          this._posthogClient = null;
+          this._scarfClient = null;
+          logger.debug(
+            `Telemetry disabled - unknown environment: ${this._runtimeEnvironment}`
+          );
+        } else {
+          logger.info(
+            "Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable."
+          );
+          if (this._runtimeEnvironment !== "browser") {
+            try {
+              const posthogOptions = {
+                host: this.HOST,
+                disableGeoip: false
+              };
+              if (isServerlessEnvironment) {
+                posthogOptions.flushAt = 1;
+                posthogOptions.flushInterval = 0;
+              }
+              this._posthogClient = new import_posthog_node.PostHog(
+                this.PROJECT_API_KEY,
+                posthogOptions
+              );
+            } catch (e) {
+              logger.warn(`Failed to initialize PostHog telemetry: ${e}`);
+              this._posthogClient = null;
+            }
+          } else {
+            this._posthogClient = null;
+          }
+          try {
+            this._scarfClient = new ScarfEventLogger(this.SCARF_GATEWAY_URL, 3e3);
+          } catch (e) {
+            logger.warn(`Failed to initialize Scarf telemetry: ${e}`);
+            this._scarfClient = null;
+          }
+        }
+      }
+      /**
+       * Get the detected runtime environment
+       */
+      get runtimeEnvironment() {
+        return this._runtimeEnvironment;
+      }
+      /**
+       * Get the storage capability for this environment
+       */
+      get storageCapability() {
+        return this._storageCapability;
+      }
+      static getInstance() {
+        if (!_Telemetry.instance) {
+          _Telemetry.instance = new _Telemetry();
+        }
+        return _Telemetry.instance;
+      }
+      /**
+       * Set the source identifier for telemetry events.
+       * This allows tracking usage from different applications.
+       * @param source - The source identifier (e.g., "my-app", "cli", "vs-code-extension")
+       */
+      setSource(source) {
+        this._source = source;
+        logger.debug(`Telemetry source set to: ${source}`);
+      }
+      /**
+       * Get the current source identifier.
+       */
+      getSource() {
+        return this._source;
+      }
+      /**
+       * Check if telemetry is enabled.
+       * Returns false if telemetry was disabled via environment variable or if not in Node.js environment.
+       */
+      get isEnabled() {
+        return this._posthogClient !== null || this._scarfClient !== null;
+      }
+      get userId() {
+        if (this._currUserId) {
+          return this._currUserId;
+        }
+        try {
+          switch (this._storageCapability) {
+            case "filesystem":
+              this._currUserId = this.getUserIdFromFilesystem();
+              break;
+            case "localStorage":
+              this._currUserId = this.getUserIdFromLocalStorage();
+              break;
+            case "session-only":
+            default:
+              this._currUserId = `session-${generateUUID()}`;
+              logger.debug(
+                `Using session-based user ID (${this._runtimeEnvironment} environment)`
+              );
+              break;
+          }
+          if (this._storageCapability === "filesystem" && this._currUserId) {
+            this.trackPackageDownloadInternal(this._currUserId, {
+              triggered_by: "user_id_property"
+            }).catch((e) => logger.debug(`Failed to track package download: ${e}`));
+          }
+        } catch (e) {
+          logger.debug(`Failed to get/create user ID: ${e}`);
+          this._currUserId = this.UNKNOWN_USER_ID;
+        }
+        return this._currUserId;
+      }
+      /**
+       * Get or create user ID from filesystem (Node.js/Bun)
+       */
+      getUserIdFromFilesystem() {
+        const isFirstTime = !fs.existsSync(this.USER_ID_PATH);
+        if (isFirstTime) {
+          logger.debug(`Creating user ID path: ${this.USER_ID_PATH}`);
+          fs.mkdirSync(path.dirname(this.USER_ID_PATH), { recursive: true });
+          const newUserId = generateUUID();
+          fs.writeFileSync(this.USER_ID_PATH, newUserId);
+          logger.debug(`User ID path created: ${this.USER_ID_PATH}`);
+          return newUserId;
+        }
+        return fs.readFileSync(this.USER_ID_PATH, "utf-8").trim();
+      }
+      /**
+       * Get or create user ID from localStorage (Browser)
+       */
+      getUserIdFromLocalStorage() {
+        try {
+          let userId = localStorage.getItem(USER_ID_STORAGE_KEY);
+          if (!userId) {
+            userId = generateUUID();
+            localStorage.setItem(USER_ID_STORAGE_KEY, userId);
+            logger.debug(`Created new browser user ID`);
+          }
+          return userId;
+        } catch (e) {
+          logger.debug(`localStorage access failed: ${e}`);
+          return `session-${generateUUID()}`;
+        }
+      }
+      async capture(event) {
+        logger.debug(
+          `CAPTURE: posthog: ${this._posthogClient !== null}, scarf: ${this._scarfClient !== null}`
+        );
+        if (!this._posthogClient && !this._scarfClient) {
+          return;
+        }
+        if (this._posthogClient) {
+          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({
+              distinctId: this.userId,
+              event: event.name,
+              properties
+            });
+          } catch (e) {
+            logger.debug(`Failed to track PostHog 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);
+          } catch (e) {
+            logger.debug(`Failed to track Scarf event ${event.name}: ${e}`);
+          }
+        }
+      }
+      /**
+       * Track package download event.
+       * This is a public wrapper that safely accesses userId.
+       */
+      async trackPackageDownload(properties) {
+        return this.trackPackageDownloadInternal(this.userId, properties);
+      }
+      /**
+       * Internal method to track package download with explicit userId.
+       * This avoids circular dependency when called from the userId getter.
+       */
+      async trackPackageDownloadInternal(userId, properties) {
+        if (!this._scarfClient) {
+          return;
+        }
+        if (this._storageCapability !== "filesystem") {
+          return;
+        }
+        try {
+          const currentVersion = getPackageVersion();
+          let shouldTrack = false;
+          let firstDownload = false;
+          if (!fs.existsSync(this.VERSION_DOWNLOAD_PATH)) {
+            shouldTrack = true;
+            firstDownload = true;
+            fs.mkdirSync(path.dirname(this.VERSION_DOWNLOAD_PATH), {
+              recursive: true
+            });
+            fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
+          } else {
+            const savedVersion = fs.readFileSync(this.VERSION_DOWNLOAD_PATH, "utf-8").trim();
+            if (currentVersion > savedVersion) {
+              shouldTrack = true;
+              firstDownload = false;
+              fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
+            }
+          }
+          if (shouldTrack) {
+            logger.debug(
+              `Tracking package download event with properties: ${JSON.stringify(properties)}`
+            );
+            const eventProperties = { ...properties || {} };
+            eventProperties.mcp_use_version = currentVersion;
+            eventProperties.user_id = userId;
+            eventProperties.event = "package_download";
+            eventProperties.first_download = firstDownload;
+            eventProperties.language = "typescript";
+            eventProperties.source = this._source;
+            eventProperties.runtime = this._runtimeEnvironment;
+            await this._scarfClient.logEvent(eventProperties);
+          }
+        } catch (e) {
+          logger.debug(`Failed to track Scarf package_download event: ${e}`);
+        }
+      }
+      // ============================================================================
+      // Agent Events
+      // ============================================================================
+      async trackAgentExecution(data) {
+        if (!this.isEnabled) return;
+        const event = new MCPAgentExecutionEvent(data);
+        await this.capture(event);
+      }
+      // ============================================================================
+      // Server Events
+      // ============================================================================
+      /**
+       * Track server run event directly from an MCPServer instance.
+       * This extracts the necessary data from the server and creates the event.
+       * @param server - The MCPServer instance (or any object conforming to MCPServerTelemetryInfo)
+       * @param transport - The transport type (e.g., "http", "stdio", "supabase")
+       */
+      async trackServerRunFromServer(server, transport) {
+        if (!this.isEnabled) return;
+        const data = createServerRunEventData(server, transport);
+        const event = new ServerRunEvent(data);
+        await this.capture(event);
+      }
+      async trackServerInitialize(data) {
+        if (!this.isEnabled) return;
+        const event = new ServerInitializeEvent(data);
+        await this.capture(event);
+      }
+      async trackServerToolCall(data) {
+        if (!this.isEnabled) return;
+        const event = new ServerToolCallEvent(data);
+        await this.capture(event);
+      }
+      async trackServerResourceCall(data) {
+        if (!this.isEnabled) return;
+        const event = new ServerResourceCallEvent(data);
+        await this.capture(event);
+      }
+      async trackServerPromptCall(data) {
+        if (!this.isEnabled) return;
+        const event = new ServerPromptCallEvent(data);
+        await this.capture(event);
+      }
+      async trackServerContext(data) {
+        if (!this.isEnabled) return;
+        const event = new ServerContextEvent(data);
+        await this.capture(event);
+      }
+      // ============================================================================
+      // Client Events
+      // ============================================================================
+      async trackMCPClientInit(data) {
+        if (!this.isEnabled) return;
+        const event = new MCPClientInitEvent(data);
+        await this.capture(event);
+      }
+      async trackConnectorInit(data) {
+        if (!this.isEnabled) return;
+        const event = new ConnectorInitEvent(data);
+        await this.capture(event);
+      }
+      flush() {
+        if (this._posthogClient) {
+          try {
+            this._posthogClient.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() {
+        if (this._posthogClient) {
+          try {
+            this._posthogClient.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 init_telemetry2 = __esm({
+  "src/telemetry/index.ts"() {
+    "use strict";
+    init_telemetry();
+    init_events();
+    init_telemetry();
+    init_utils();
+  }
+});
+
 // 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) {
-  return requestContextStorage.run(context, fn);
+async function runWithContext(context, fn, sessionId) {
+  return requestContextStorage.run({ honoContext: context, sessionId }, fn);
 }
 function getRequestContext() {
-  return requestContextStorage.getStore();
+  return requestContextStorage.getStore()?.honoContext;
+}
+function getSessionId() {
+  return requestContextStorage.getStore()?.sessionId;
 }
 function hasRequestContext() {
   return requestContextStorage.getStore() !== void 0;
@@ -146,6 +1265,7 @@ var init_context_storage = __esm({
     requestContextStorage = new import_node_async_hooks.AsyncLocalStorage();
     __name(runWithContext, "runWithContext");
     __name(getRequestContext, "getRequestContext");
+    __name(getSessionId, "getSessionId");
     __name(hasRequestContext, "hasRequestContext");
   }
 });
@@ -174,13 +1294,16 @@ var init_errors = __esm({
 // 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) {
@@ -365,6 +1488,9 @@ function createSampleMethod(createMessage, progressToken, sendNotification2) {
         `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);
@@ -387,6 +1513,9 @@ function createElicitMethod(elicitInput) {
     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);
@@ -395,9 +1524,10 @@ function createElicitMethod(elicitInput) {
           data: validatedData
         };
       } catch (error2) {
+        const err = error2;
         throw new ElicitationValidationError(
-          `Elicitation data validation failed: ${error2.message}`,
-          error2
+          `Elicitation data validation failed: ${err.message}`,
+          err
         );
       }
     }
@@ -418,7 +1548,103 @@ function createReportProgressMethod(progressToken, sendNotification2) {
   }
   return void 0;
 }
-function createEnhancedContext(baseContext, createMessage, elicitInput, progressToken, sendNotification2) {
+function isValidLogLevel(level) {
+  return VALID_LOG_LEVELS.includes(level);
+}
+function shouldLogMessage(messageLevel, minLevel) {
+  if (!minLevel) {
+    return true;
+  }
+  if (!isValidLogLevel(messageLevel) || !isValidLogLevel(minLevel)) {
+    return true;
+  }
+  return LOG_LEVELS[messageLevel] >= LOG_LEVELS[minLevel];
+}
+function createLogMethod(sendNotification2, minLogLevel) {
+  if (!sendNotification2) {
+    return void 0;
+  }
+  return async (level, message, logger2) => {
+    if (!shouldLogMessage(level, minLogLevel)) {
+      return;
+    }
+    await sendNotification2({
+      method: "notifications/message",
+      params: {
+        level,
+        data: message,
+        logger: logger2 || "tool"
+      }
+    });
+    Telemetry.getInstance().trackServerContext({
+      contextType: "notification",
+      notificationType: "message"
+    }).catch(
+      (e) => console.debug(`Failed to track notification context: ${e}`)
+    );
+  };
+}
+function createClientCapabilityChecker(clientCapabilities) {
+  const caps = clientCapabilities || {};
+  return {
+    can(capability) {
+      return capability in caps;
+    },
+    capabilities() {
+      return { ...caps };
+    }
+  };
+}
+function createSendNotificationMethod(sessionId, sessions) {
+  if (!sessionId || !sessions) {
+    return void 0;
+  }
+  return async (method, params) => {
+    const session = sessions.get(sessionId);
+    if (!session?.sendNotification) {
+      console.warn(
+        `[MCP] Cannot send notification to session ${sessionId} - no sendNotification function`
+      );
+      return;
+    }
+    try {
+      await session.sendNotification({
+        method,
+        params: params || {}
+      });
+    } catch (error2) {
+      console.error(
+        `[MCP] Error sending notification to session ${sessionId}:`,
+        error2
+      );
+    }
+  };
+}
+function createSendNotificationToSessionMethod(sessions) {
+  if (!sessions) {
+    return void 0;
+  }
+  return async (sessionId, method, params) => {
+    const session = sessions.get(sessionId);
+    if (!session?.sendNotification) {
+      return false;
+    }
+    try {
+      await session.sendNotification({
+        method,
+        params: params || {}
+      });
+      return true;
+    } catch (error2) {
+      console.error(
+        `[MCP] Error sending notification to session ${sessionId}:`,
+        error2
+      );
+      return false;
+    }
+  };
+}
+function createEnhancedContext(baseContext, createMessage, elicitInput, progressToken, sendNotification2, minLogLevel, clientCapabilities, sessionId, sessions) {
   const enhancedContext = baseContext ? Object.create(baseContext) : {};
   enhancedContext.sample = createSampleMethod(
     createMessage,
@@ -430,15 +1656,34 @@ function createEnhancedContext(baseContext, createMessage, elicitInput, progress
     progressToken,
     sendNotification2
   );
+  enhancedContext.log = createLogMethod(sendNotification2, minLogLevel);
+  enhancedContext.client = createClientCapabilityChecker(clientCapabilities);
+  if (sessionId) {
+    enhancedContext.session = {
+      sessionId
+    };
+  }
+  const sendNotificationMethod = createSendNotificationMethod(
+    sessionId,
+    sessions
+  );
+  if (sendNotificationMethod) {
+    enhancedContext.sendNotification = sendNotificationMethod;
+  }
+  const sendNotificationToSessionMethod = createSendNotificationToSessionMethod(sessions);
+  if (sendNotificationToSessionMethod) {
+    enhancedContext.sendNotificationToSession = sendNotificationToSessionMethod;
+  }
   return enhancedContext;
 }
-var import_zod_json_schema_compat;
+var import_zod_json_schema_compat, LOG_LEVELS, VALID_LOG_LEVELS;
 var init_tool_execution_helpers = __esm({
   "src/server/tools/tool-execution-helpers.ts"() {
     "use strict";
-    import_zod_json_schema_compat = require("@modelcontextprotocol/sdk/server/zod-json-schema-compat.js");
+    import_zod_json_schema_compat = require("@mcp-use/modelcontextprotocol-sdk/server/zod-json-schema-compat.js");
     init_errors();
     init_runtime();
+    init_telemetry2();
     __name(findSessionContext, "findSessionContext");
     __name(sendProgressNotification, "sendProgressNotification");
     __name(withTimeout, "withTimeout");
@@ -446,6 +1691,32 @@ var init_tool_execution_helpers = __esm({
     __name(createSampleMethod, "createSampleMethod");
     __name(createElicitMethod, "createElicitMethod");
     __name(createReportProgressMethod, "createReportProgressMethod");
+    LOG_LEVELS = {
+      debug: 0,
+      info: 1,
+      notice: 2,
+      warning: 3,
+      error: 4,
+      critical: 5,
+      alert: 6,
+      emergency: 7
+    };
+    VALID_LOG_LEVELS = [
+      "debug",
+      "info",
+      "notice",
+      "warning",
+      "error",
+      "critical",
+      "alert",
+      "emergency"
+    ];
+    __name(isValidLogLevel, "isValidLogLevel");
+    __name(shouldLogMessage, "shouldLogMessage");
+    __name(createLogMethod, "createLogMethod");
+    __name(createClientCapabilityChecker, "createClientCapabilityChecker");
+    __name(createSendNotificationMethod, "createSendNotificationMethod");
+    __name(createSendNotificationToSessionMethod, "createSendNotificationToSessionMethod");
     __name(createEnhancedContext, "createEnhancedContext");
   }
 });
@@ -643,9 +1914,12 @@ var init_conversion2 = __esm({
 // src/server/index.ts
 var server_exports = {};
 __export(server_exports, {
+  MCPServer: () => MCPServer,
+  VERSION: () => VERSION,
   adaptConnectMiddleware: () => adaptConnectMiddleware,
   adaptMiddleware: () => adaptMiddleware,
   array: () => array,
+  audio: () => audio,
   binary: () => binary,
   buildWidgetUrl: () => buildWidgetUrl,
   createExternalUrlResource: () => createExternalUrlResource,
@@ -656,6 +1930,7 @@ __export(server_exports, {
   css: () => css,
   error: () => error,
   getAuth: () => getAuth,
+  getPackageVersion: () => getPackageVersion,
   getRequestContext: () => getRequestContext,
   hasAnyScope: () => hasAnyScope,
   hasRequestContext: () => hasRequestContext,
@@ -683,12 +1958,17 @@ __export(server_exports, {
 module.exports = __toCommonJS(server_exports);
 
 // src/server/mcp-server.ts
-var import_mcp2 = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_mcp2 = require("@mcp-use/modelcontextprotocol-sdk/server/mcp.js");
+var import_types2 = require("@mcp-use/modelcontextprotocol-sdk/types.js");
+var import_zod2 = require("zod");
+init_telemetry2();
+init_version();
 
 // src/server/widgets/index.ts
 init_runtime();
 
 // src/server/utils/response-helpers.ts
+init_runtime();
 function text(content) {
   return {
     content: [
@@ -719,7 +1999,109 @@ function image(data, mimeType = "image/png") {
   };
 }
 __name(image, "image");
-function resource(uri, mimeType, text2) {
+function getAudioMimeType(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "wav":
+      return "audio/wav";
+    case "mp3":
+      return "audio/mpeg";
+    case "ogg":
+      return "audio/ogg";
+    case "m4a":
+      return "audio/mp4";
+    case "webm":
+      return "audio/webm";
+    case "flac":
+      return "audio/flac";
+    case "aac":
+      return "audio/aac";
+    default:
+      return "audio/wav";
+  }
+}
+__name(getAudioMimeType, "getAudioMimeType");
+function arrayBufferToBase64(buffer) {
+  if (isDeno) {
+    const bytes = new Uint8Array(buffer);
+    let binary2 = "";
+    for (let i = 0; i < bytes.length; i++) {
+      binary2 += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary2);
+  } else {
+    return Buffer.from(buffer).toString("base64");
+  }
+}
+__name(arrayBufferToBase64, "arrayBufferToBase64");
+function audio(dataOrPath, mimeType) {
+  const isFilePath = dataOrPath.includes("/") || dataOrPath.includes("\\") || dataOrPath.includes(".");
+  if (isFilePath && dataOrPath.length < 1e3) {
+    return (async () => {
+      const buffer = await fsHelpers.readFile(dataOrPath);
+      const base64Data = arrayBufferToBase64(buffer);
+      const inferredMimeType = mimeType || getAudioMimeType(dataOrPath);
+      return {
+        content: [
+          {
+            type: "audio",
+            data: base64Data,
+            mimeType: inferredMimeType
+          }
+        ],
+        _meta: {
+          mimeType: inferredMimeType,
+          isAudio: true
+        }
+      };
+    })();
+  }
+  const finalMimeType = mimeType || "audio/wav";
+  return {
+    content: [
+      {
+        type: "audio",
+        data: dataOrPath,
+        mimeType: finalMimeType
+      }
+    ],
+    _meta: {
+      mimeType: finalMimeType,
+      isAudio: true
+    }
+  };
+}
+__name(audio, "audio");
+function resource(uri, mimeTypeOrContent, text2) {
+  if (typeof mimeTypeOrContent === "object" && mimeTypeOrContent !== null && "content" in mimeTypeOrContent) {
+    const contentResult = mimeTypeOrContent;
+    let extractedText;
+    let extractedMimeType;
+    if (contentResult._meta && typeof contentResult._meta === "object") {
+      const meta = contentResult._meta;
+      if (meta.mimeType && typeof meta.mimeType === "string") {
+        extractedMimeType = meta.mimeType;
+      }
+    }
+    if (contentResult.content && contentResult.content.length > 0) {
+      const firstContent = contentResult.content[0];
+      if (firstContent.type === "text" && "text" in firstContent) {
+        extractedText = firstContent.text;
+      }
+    }
+    const resourceContent2 = {
+      type: "resource",
+      resource: {
+        uri,
+        ...extractedMimeType && { mimeType: extractedMimeType },
+        ...extractedText && { text: extractedText }
+      }
+    };
+    return {
+      content: [resourceContent2]
+    };
+  }
+  const mimeType = mimeTypeOrContent;
   const resourceContent = {
     type: "resource",
     resource: {
@@ -858,37 +2240,12 @@ function binary(base64Data, mimeType) {
 }
 __name(binary, "binary");
 function widget(config) {
-  const {
-    name,
-    data,
-    message,
-    invoking,
-    invoked,
-    widgetAccessible = true,
-    resultCanProduceWidget = true,
-    buildId
-  } = config;
-  const randomId = Math.random().toString(36).substring(2, 15);
-  const buildIdPart = buildId ? `-${buildId}` : "";
-  const uniqueUri = `ui://widget/${name}${buildIdPart}-${randomId}.html`;
-  const metadata = {
-    "openai/outputTemplate": uniqueUri,
-    "openai/widgetAccessible": widgetAccessible,
-    "openai/resultCanProduceWidget": resultCanProduceWidget
-  };
-  if (invoking) {
-    metadata["openai/toolInvocation/invoking"] = invoking;
-  }
-  if (invoked) {
-    metadata["openai/toolInvocation/invoked"] = invoked;
-  }
-  const displayMessage = message || `Displaying ${name}`;
+  const { data, message } = config;
   return {
-    _meta: metadata,
     content: [
       {
         type: "text",
-        text: displayMessage
+        text: message || ""
       }
     ],
     // structuredContent will be injected as window.openai.toolOutput by Apps SDK
@@ -998,7 +2355,7 @@ function parseTemplateUri(template, uri) {
   const params = {};
   let regexPattern = template.replace(/[.*+?^$()[\]\\|]/g, "\\$&");
   const paramNames = [];
-  regexPattern = regexPattern.replace(/\\\{([^}]+)\\\}/g, (_, paramName) => {
+  regexPattern = regexPattern.replace(/\{([^}]+)\}/g, (_, paramName) => {
     paramNames.push(paramName);
     return "([^/]+)";
   });
@@ -1272,11 +2629,11 @@ function createHonoProxy(target, app) {
       if (prop === "use") {
         return async (...args) => {
           const hasPath = typeof args[0] === "string";
-          const path = hasPath ? args[0] : "*";
+          const path2 = hasPath ? args[0] : "*";
           const handlers = hasPath ? args.slice(1) : args;
           const adaptedHandlers = handlers.map((handler) => {
             if (isExpressMiddleware(handler)) {
-              return { __isExpressMiddleware: true, handler, path };
+              return { __isExpressMiddleware: true, handler, path: path2 };
             }
             return handler;
           });
@@ -1292,13 +2649,13 @@ function createHonoProxy(target, app) {
                     h.path
                   );
                   if (hasPath) {
-                    app.use(path, adapted);
+                    app.use(path2, adapted);
                   } else {
                     app.use(adapted);
                   }
                 } else {
                   if (hasPath) {
-                    app.use(path, h);
+                    app.use(path2, h);
                   } else {
                     app.use(h);
                   }
@@ -1566,6 +2923,7 @@ function createWidgetRegistration(widgetName, metadata, html2, serverConfig, isD
   const props = metadata.inputs || {};
   const description = metadata.description || `Widget: ${widgetName}`;
   const title = metadata.title || widgetName;
+  const exposeAsTool = metadata.exposeAsTool !== void 0 ? metadata.exposeAsTool : true;
   const mcp_connect_domain = serverConfig.serverBaseUrl ? new URL(serverConfig.serverBaseUrl || "").origin : null;
   return {
     name: widgetName,
@@ -1581,7 +2939,8 @@ function createWidgetRegistration(widgetName, metadata, html2, serverConfig, isD
         type: "appsSdk",
         props,
         html: html2,
-        dev: isDev
+        dev: isDev,
+        exposeAsTool
       },
       ...metadata._meta || {}
     },
@@ -1707,12 +3066,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: fs } = await import("fs");
+  const { promises: fs2 } = await import("fs");
   const baseRoute = options?.baseRoute || "/mcp-use/widgets";
   const resourcesDir = options?.resourcesDir || "resources";
   const srcDir = pathHelpers.join(getCwd(), resourcesDir);
   try {
-    await fs.access(srcDir);
+    await fs2.access(srcDir);
   } catch (error2) {
     console.log(
       `[WIDGETS] No ${resourcesDir}/ directory found - skipping widget serving`
@@ -1721,7 +3080,7 @@ async function mountWidgetsDev(app, serverConfig, registerWidget, options) {
   }
   const entries = [];
   try {
-    const files = await fs.readdir(srcDir, { withFileTypes: true });
+    const files = await fs2.readdir(srcDir, { withFileTypes: true });
     for (const dirent of files) {
       if (dirent.name.startsWith("._") || dirent.name.startsWith(".DS_Store")) {
         continue;
@@ -1734,7 +3093,7 @@ async function mountWidgetsDev(app, serverConfig, registerWidget, options) {
       } else if (dirent.isDirectory()) {
         const widgetPath = pathHelpers.join(srcDir, dirent.name, "widget.tsx");
         try {
-          await fs.access(widgetPath);
+          await fs2.access(widgetPath);
           entries.push({
             name: dirent.name,
             path: widgetPath
@@ -1752,7 +3111,7 @@ async function mountWidgetsDev(app, serverConfig, registerWidget, options) {
     return;
   }
   const tempDir = pathHelpers.join(getCwd(), TMP_MCP_USE_DIR);
-  await fs.mkdir(tempDir, { recursive: true }).catch(() => {
+  await fs2.mkdir(tempDir, { recursive: true }).catch(() => {
   });
   let createServer;
   let react;
@@ -1786,7 +3145,7 @@ async function mountWidgetsDev(app, serverConfig, registerWidget, options) {
   });
   for (const widget2 of widgets) {
     const widgetTempDir = pathHelpers.join(tempDir, widget2.name);
-    await fs.mkdir(widgetTempDir, { recursive: true });
+    await fs2.mkdir(widgetTempDir, { recursive: true });
     const resourcesPath = pathHelpers.join(getCwd(), resourcesDir);
     const relativeResourcesPath = pathHelpers.relative(widgetTempDir, resourcesPath).replace(/\\/g, "/");
     const cssContent = `@import "tailwindcss";
@@ -1794,7 +3153,7 @@ async function mountWidgetsDev(app, serverConfig, registerWidget, options) {
 /* Configure Tailwind to scan the resources directory */
 @source "${relativeResourcesPath}";
 `;
-    await fs.writeFile(
+    await fs2.writeFile(
       pathHelpers.join(widgetTempDir, "styles.css"),
       cssContent,
       "utf8"
@@ -1822,12 +3181,12 @@ if (container && Component) {
     <script type="module" src="${baseRoute}/${widget2.name}/entry.tsx"></script>
   </body>
 </html>`;
-    await fs.writeFile(
+    await fs2.writeFile(
       pathHelpers.join(widgetTempDir, "entry.tsx"),
       entryContent,
       "utf8"
     );
-    await fs.writeFile(
+    await fs2.writeFile(
       pathHelpers.join(widgetTempDir, "index.html"),
       htmlContent,
       "utf8"
@@ -1861,10 +3220,42 @@ if (container && Component) {
       console.log(`[WIDGETS] Watching resources directory: ${resourcesPath}`);
     }
   };
+  const nodeStubsPlugin = {
+    name: "node-stubs",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === "posthog-node" || id.startsWith("posthog-node/")) {
+        return "\0virtual:posthog-node-stub";
+      }
+      return null;
+    },
+    load(id) {
+      if (id === "\0virtual:posthog-node-stub") {
+        return `
+export class PostHog {
+  constructor() {}
+  capture() {}
+  identify() {}
+  alias() {}
+  flush() { return Promise.resolve(); }
+  shutdown() { return Promise.resolve(); }
+}
+export default PostHog;
+`;
+      }
+      return null;
+    }
+  };
   const viteServer = await createServer({
     root: tempDir,
     base: baseRoute + "/",
-    plugins: [ssrCssPlugin, watchResourcesPlugin, tailwindcss(), react()],
+    plugins: [
+      nodeStubsPlugin,
+      ssrCssPlugin,
+      watchResourcesPlugin,
+      tailwindcss(),
+      react()
+    ],
     resolve: {
       alias: {
         "@": pathHelpers.join(getCwd(), resourcesDir)
@@ -1885,12 +3276,15 @@ if (container && Component) {
     // Explicitly tell Vite to watch files outside root
     // This is needed because widget entry files import from resources directory
     optimizeDeps: {
-      // Don't optimize dependencies that might change
-      exclude: []
+      // Exclude Node.js-only packages from browser bundling
+      // posthog-node is for server-side telemetry and doesn't work in browser
+      exclude: ["posthog-node"]
     },
     ssr: {
       // Force Vite to transform these packages in SSR instead of using external requires
-      noExternal: ["@openai/apps-sdk-ui", "react-router"]
+      noExternal: ["@openai/apps-sdk-ui", "react-router"],
+      // Mark Node.js-only packages as external in SSR mode
+      external: ["posthog-node"]
     },
     define: {
       // Define process.env for SSR context
@@ -2149,25 +3543,31 @@ function setupWidgetRoutes(app, serverConfig) {
 __name(setupWidgetRoutes, "setupWidgetRoutes");
 
 // src/server/widgets/ui-resource-registration.ts
-function uiResourceRegistration(definition) {
+function uiResourceRegistration(server, definition) {
   const displayName = definition.title || definition.name;
+  if (definition.type === "appsSdk" && definition._meta) {
+    server.widgetDefinitions.set(
+      definition.name,
+      definition._meta
+    );
+  }
   let resourceUri;
   let mimeType;
   switch (definition.type) {
     case "externalUrl":
-      resourceUri = generateWidgetUri(definition.widget, this.buildId);
+      resourceUri = generateWidgetUri(definition.widget, server.buildId);
       mimeType = "text/uri-list";
       break;
     case "rawHtml":
-      resourceUri = generateWidgetUri(definition.name, this.buildId);
+      resourceUri = generateWidgetUri(definition.name, server.buildId);
       mimeType = "text/html";
       break;
     case "remoteDom":
-      resourceUri = generateWidgetUri(definition.name, this.buildId);
+      resourceUri = generateWidgetUri(definition.name, server.buildId);
       mimeType = "application/vnd.mcp-ui.remote-dom+javascript";
       break;
     case "appsSdk":
-      resourceUri = generateWidgetUri(definition.name, this.buildId, ".html");
+      resourceUri = generateWidgetUri(definition.name, server.buildId, ".html");
       mimeType = "text/html+skybridge";
       break;
     default:
@@ -2176,12 +3576,12 @@ function uiResourceRegistration(definition) {
       );
   }
   const serverConfig = {
-    serverHost: this.serverHost,
-    serverPort: this.serverPort || 3e3,
-    serverBaseUrl: this.serverBaseUrl,
-    buildId: this.buildId
+    serverHost: server.serverHost,
+    serverPort: server.serverPort || 3e3,
+    serverBaseUrl: server.serverBaseUrl,
+    buildId: server.buildId
   };
-  this.resource({
+  server.resource({
     name: definition.name,
     uri: resourceUri,
     title: definition.title,
@@ -2203,9 +3603,9 @@ function uiResourceRegistration(definition) {
     }, "readCallback")
   });
   if (definition.type === "appsSdk") {
-    const buildIdPart = this.buildId ? `-${this.buildId}` : "";
+    const buildIdPart = server.buildId ? `-${server.buildId}` : "";
     const uriTemplate = `ui://widget/${definition.name}${buildIdPart}-{id}.html`;
-    this.resourceTemplate({
+    server.resourceTemplate({
       name: `${definition.name}-dynamic`,
       resourceTemplate: {
         uriTemplate,
@@ -2230,70 +3630,77 @@ function uiResourceRegistration(definition) {
       }, "readCallback")
     });
   }
-  const toolMetadata = definition._meta || {};
-  if (definition.type === "appsSdk" && definition.appsSdkMetadata) {
-    toolMetadata["openai/outputTemplate"] = resourceUri;
-    const toolMetadataFields = [
-      "openai/toolInvocation/invoking",
-      "openai/toolInvocation/invoked",
-      "openai/widgetAccessible",
-      "openai/resultCanProduceWidget"
-    ];
-    for (const field of toolMetadataFields) {
-      if (definition.appsSdkMetadata[field] !== void 0) {
-        toolMetadata[field] = definition.appsSdkMetadata[field];
+  const widgetMetadata = definition._meta?.["mcp-use/widget"];
+  const exposeAsTool = definition.exposeAsTool ?? widgetMetadata?.exposeAsTool ?? true;
+  if (exposeAsTool) {
+    const toolMetadata = definition._meta || {};
+    if (definition.type === "appsSdk" && definition.appsSdkMetadata) {
+      toolMetadata["openai/outputTemplate"] = resourceUri;
+      const toolMetadataFields = [
+        "openai/toolInvocation/invoking",
+        "openai/toolInvocation/invoked",
+        "openai/widgetAccessible",
+        "openai/resultCanProduceWidget"
+      ];
+      for (const field of toolMetadataFields) {
+        if (definition.appsSdkMetadata[field] !== void 0) {
+          toolMetadata[field] = definition.appsSdkMetadata[field];
+        }
       }
     }
-  }
-  this.tool({
-    name: definition.name,
-    title: definition.title,
-    description: definition.description,
-    inputs: convertPropsToInputs(definition.props),
-    _meta: Object.keys(toolMetadata).length > 0 ? toolMetadata : void 0,
-    cb: /* @__PURE__ */ __name(async (params) => {
-      const uiResource = await createWidgetUIResource(
-        definition,
-        params,
-        serverConfig
-      );
-      if (definition.type === "appsSdk") {
-        const randomId = Math.random().toString(36).substring(2, 15);
-        const uniqueUri = generateWidgetUri(
-          definition.name,
-          this.buildId,
-          ".html",
-          randomId
+    server.tool(
+      {
+        name: definition.name,
+        title: definition.title,
+        description: definition.description,
+        inputs: convertPropsToInputs(definition.props),
+        annotations: definition.toolAnnotations,
+        _meta: Object.keys(toolMetadata).length > 0 ? toolMetadata : void 0
+      },
+      async (params) => {
+        const uiResource = await createWidgetUIResource(
+          definition,
+          params,
+          serverConfig
         );
-        const uniqueToolMetadata = {
-          ...toolMetadata,
-          "openai/outputTemplate": uniqueUri
-        };
+        if (definition.type === "appsSdk") {
+          const randomId = Math.random().toString(36).substring(2, 15);
+          const uniqueUri = generateWidgetUri(
+            definition.name,
+            server.buildId,
+            ".html",
+            randomId
+          );
+          const uniqueToolMetadata = {
+            ...toolMetadata,
+            "openai/outputTemplate": uniqueUri
+          };
+          return {
+            _meta: uniqueToolMetadata,
+            content: [
+              {
+                type: "text",
+                text: `Displaying ${displayName}`
+              }
+            ],
+            // structuredContent will be injected as window.openai.toolOutput by Apps SDK
+            structuredContent: params
+          };
+        }
         return {
-          _meta: uniqueToolMetadata,
           content: [
             {
               type: "text",
-              text: `Displaying ${displayName}`
-            }
-          ],
-          // structuredContent will be injected as window.openai.toolOutput by Apps SDK
-          structuredContent: params
+              text: `Displaying ${displayName}`,
+              description: `Show MCP-UI widget for ${displayName}`
+            },
+            uiResource
+          ]
         };
       }
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Displaying ${displayName}`,
-            description: `Show MCP-UI widget for ${displayName}`
-          },
-          uiResource
-        ]
-      };
-    }, "cb")
-  });
-  return this;
+    );
+  }
+  return server;
 }
 __name(uiResourceRegistration, "uiResourceRegistration");
 
@@ -2431,7 +3838,7 @@ function toolRegistration(toolDefinition, callback) {
       const initialRequestContext = getRequestContext();
       const extraProgressToken = extra?._meta?.progressToken;
       const extraSendNotification = extra?.sendNotification;
-      const { requestContext, progressToken, sendNotification: sendNotification2 } = findSessionContext(
+      const { requestContext, session, progressToken, sendNotification: sendNotification2 } = findSessionContext(
         this.sessions,
         initialRequestContext,
         extraProgressToken,
@@ -2442,7 +3849,9 @@ function toolRegistration(toolDefinition, callback) {
         this.createMessage.bind(this),
         this.server.server.elicitInput.bind(this.server.server),
         progressToken,
-        sendNotification2
+        sendNotification2,
+        session?.logLevel,
+        session?.clientCapabilities
       );
       const executeCallback = /* @__PURE__ */ __name(async () => {
         if (actualCallback.length >= 2) {
@@ -2465,8 +3874,154 @@ __name(toolRegistration, "toolRegistration");
 init_tool_execution_helpers();
 
 // src/server/resources/index.ts
-var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_mcp = require("@mcp-use/modelcontextprotocol-sdk/server/mcp.js");
 init_conversion();
+
+// src/server/resources/subscriptions.ts
+var import_types = require("@mcp-use/modelcontextprotocol-sdk/types.js");
+init_context_storage();
+var ResourceSubscriptionManager = class {
+  static {
+    __name(this, "ResourceSubscriptionManager");
+  }
+  /**
+   * Tracks resource subscriptions per session
+   * Map structure: uri -> Set<sessionId>
+   */
+  subscriptions = /* @__PURE__ */ new Map();
+  /**
+   * Register subscription handlers with an MCP server instance
+   *
+   * @param server - The native MCP server instance
+   * @param sessions - Map of active sessions
+   */
+  registerHandlers(server, sessions) {
+    server.server.setRequestHandler(
+      import_types.SubscribeRequestSchema,
+      async (request) => {
+        const { uri } = request.params;
+        const sessionId = this.getSessionIdFromContext(sessions, server);
+        if (!sessionId) {
+          console.warn(
+            `[MCP] Could not determine session ID for resource subscription to ${uri}`
+          );
+          return {};
+        }
+        if (!this.subscriptions.has(uri)) {
+          this.subscriptions.set(uri, /* @__PURE__ */ new Set());
+        }
+        this.subscriptions.get(uri).add(sessionId);
+        console.log(
+          `[MCP] Session ${sessionId} subscribed to resource: ${uri}`
+        );
+        return {};
+      }
+    );
+    server.server.setRequestHandler(
+      import_types.UnsubscribeRequestSchema,
+      async (request) => {
+        const { uri } = request.params;
+        const sessionId = this.getSessionIdFromContext(sessions, server);
+        if (!sessionId) {
+          console.warn(
+            `[MCP] Could not determine session ID for resource unsubscribe from ${uri}`
+          );
+          return {};
+        }
+        const subscribers = this.subscriptions.get(uri);
+        if (subscribers) {
+          subscribers.delete(sessionId);
+          if (subscribers.size === 0) {
+            this.subscriptions.delete(uri);
+          }
+          console.log(
+            `[MCP] Session ${sessionId} unsubscribed from resource: ${uri}`
+          );
+        }
+        return {};
+      }
+    );
+  }
+  /**
+   * Get session ID from request context or sessions map
+   *
+   * @param sessions - Map of active sessions
+   * @param server - The server instance to match against
+   * @returns The session ID, or undefined if not found
+   */
+  getSessionIdFromContext(sessions, server) {
+    const requestContext = getRequestContext();
+    let sessionId;
+    if (requestContext) {
+      sessionId = requestContext.req.header("mcp-session-id");
+    }
+    if (!sessionId) {
+      for (const [sid, session] of sessions.entries()) {
+        if (session.server === server) {
+          sessionId = sid;
+          break;
+        }
+      }
+    }
+    return sessionId;
+  }
+  /**
+   * Notify subscribed clients that a resource has been updated
+   *
+   * This method sends a `notifications/resources/updated` notification to all
+   * sessions that have subscribed to the specified resource URI.
+   *
+   * @param uri - The URI of the resource that changed
+   * @param sessions - Map of active sessions
+   * @returns Promise that resolves when all notifications have been sent
+   */
+  async notifyResourceUpdated(uri, sessions) {
+    const subscribers = this.subscriptions.get(uri);
+    if (!subscribers || subscribers.size === 0) {
+      return;
+    }
+    console.log(
+      `[MCP] Notifying ${subscribers.size} subscriber(s) of resource update: ${uri}`
+    );
+    for (const sessionId of subscribers) {
+      const session = sessions.get(sessionId);
+      if (session?.server) {
+        try {
+          await session.server.server.sendResourceUpdated({ uri });
+          console.log(
+            `[MCP] Sent resource update notification to session ${sessionId}`
+          );
+        } catch (error2) {
+          console.error(
+            `[MCP] Failed to send resource update notification to session ${sessionId}:`,
+            error2
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Clean up resource subscriptions for a closed session
+   *
+   * This method is called automatically when a session is closed to remove
+   * all resource subscriptions associated with that session.
+   *
+   * @param sessionId - The session ID to clean up
+   */
+  cleanupSession(sessionId) {
+    for (const [uri, subscribers] of this.subscriptions) {
+      subscribers.delete(sessionId);
+      if (subscribers.size === 0) {
+        this.subscriptions.delete(uri);
+      }
+    }
+    console.log(
+      `[MCP] Cleaned up resource subscriptions for session ${sessionId}`
+    );
+  }
+};
+
+// src/server/resources/index.ts
 function registerResource(resourceDefinition, callback) {
   const actualCallback = callback || resourceDefinition.readCallback;
   if (!actualCallback) {
@@ -2525,24 +4080,25 @@ function registerResourceTemplate(resourceTemplateDefinition, callback) {
       `Resource template '${resourceTemplateDefinition.name}' must have either a readCallback property or a callback parameter`
     );
   }
-  const template = new import_mcp.ResourceTemplate(
-    resourceTemplateDefinition.resourceTemplate.uriTemplate,
-    {
-      list: void 0,
-      // Optional: callback to list all matching resources
-      complete: void 0
-      // Optional: callback for auto-completion
-    }
-  );
+  const isFlatStructure = "uriTemplate" in resourceTemplateDefinition;
+  const uriTemplate = isFlatStructure ? resourceTemplateDefinition.uriTemplate : resourceTemplateDefinition.resourceTemplate.uriTemplate;
+  const mimeType = isFlatStructure ? resourceTemplateDefinition.mimeType : resourceTemplateDefinition.resourceTemplate.mimeType;
+  const templateDescription = isFlatStructure ? void 0 : resourceTemplateDefinition.resourceTemplate.description;
+  const template = new import_mcp.ResourceTemplate(uriTemplate, {
+    list: void 0,
+    // Optional: callback to list all matching resources
+    complete: void 0
+    // Optional: callback for auto-completion
+  });
   const metadata = {};
   if (resourceTemplateDefinition.title) {
     metadata.title = resourceTemplateDefinition.title;
   }
-  if (resourceTemplateDefinition.description || resourceTemplateDefinition.resourceTemplate.description) {
-    metadata.description = resourceTemplateDefinition.description || resourceTemplateDefinition.resourceTemplate.description;
+  if (resourceTemplateDefinition.description || templateDescription) {
+    metadata.description = resourceTemplateDefinition.description || templateDescription;
   }
-  if (resourceTemplateDefinition.resourceTemplate.mimeType) {
-    metadata.mimeType = resourceTemplateDefinition.resourceTemplate.mimeType;
+  if (mimeType) {
+    metadata.mimeType = mimeType;
   }
   if (resourceTemplateDefinition.annotations) {
     metadata.annotations = resourceTemplateDefinition.annotations;
@@ -2552,10 +4108,7 @@ function registerResourceTemplate(resourceTemplateDefinition, callback) {
     template,
     metadata,
     async (uri) => {
-      const params = this.parseTemplateUri(
-        resourceTemplateDefinition.resourceTemplate.uriTemplate,
-        uri.toString()
-      );
+      const params = this.parseTemplateUri(uriTemplate, uri.toString());
       const { getRequestContext: getRequestContext2, runWithContext: runWithContext2 } = await Promise.resolve().then(() => (init_context_storage(), context_storage_exports));
       const { findSessionContext: findSessionContext2 } = await Promise.resolve().then(() => (init_tool_execution_helpers(), tool_execution_helpers_exports));
       const initialRequestContext = getRequestContext2();
@@ -2570,8 +4123,12 @@ function registerResourceTemplate(resourceTemplateDefinition, callback) {
       const executeCallback = /* @__PURE__ */ __name(async () => {
         if (actualCallback.length >= 3) {
           return await actualCallback(uri, params, enhancedContext);
+        } else if (actualCallback.length === 2) {
+          return await actualCallback(uri, params);
+        } else if (actualCallback.length === 1) {
+          return await actualCallback(uri);
         }
-        return await actualCallback(uri, params);
+        return await actualCallback();
       }, "executeCallback");
       const result = requestContext ? await runWithContext2(requestContext, executeCallback) : await executeCallback();
       if ("contents" in result && Array.isArray(result.contents)) {
@@ -2602,8 +4159,10 @@ function registerPrompt(promptDefinition, callback) {
     argsSchema = this.convertZodSchemaToParams(
       promptDefinition.schema
     );
+  } else if (promptDefinition.args && promptDefinition.args.length > 0) {
+    argsSchema = this.createParamsSchema(promptDefinition.args);
   } else {
-    argsSchema = this.createParamsSchema(promptDefinition.args || []);
+    argsSchema = void 0;
   }
   const wrappedCallback = /* @__PURE__ */ __name(async (params, extra) => {
     const { getRequestContext: getRequestContext2, runWithContext: runWithContext2 } = await Promise.resolve().then(() => (init_context_storage(), context_storage_exports));
@@ -2886,7 +4445,7 @@ init_tool_execution_helpers();
 init_context_storage();
 
 // src/server/sessions/session-manager.ts
-function startIdleCleanup(sessions, idleTimeoutMs) {
+function startIdleCleanup(sessions, idleTimeoutMs, mcpServerInstance) {
   if (idleTimeoutMs <= 0) {
     return void 0;
   }
@@ -2904,6 +4463,7 @@ function startIdleCleanup(sessions, idleTimeoutMs) {
       );
       for (const sessionId of expiredSessions) {
         sessions.delete(sessionId);
+        mcpServerInstance?.cleanupSessionSubscriptions?.(sessionId);
       }
     }
   }, 6e4);
@@ -2912,13 +4472,18 @@ __name(startIdleCleanup, "startIdleCleanup");
 
 // src/server/endpoints/mount-mcp.ts
 init_runtime();
+init_telemetry2();
 async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMode2) {
-  const { FetchStreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/experimental/fetch-streamable-http/index.js");
+  const { FetchStreamableHTTPServerTransport } = await import("@mcp-use/modelcontextprotocol-sdk/experimental/fetch-streamable-http/index.js");
   const idleTimeoutMs = config.sessionIdleTimeoutMs ?? 3e5;
   const transports = /* @__PURE__ */ new Map();
   let idleCleanupInterval;
   if (idleTimeoutMs > 0) {
-    idleCleanupInterval = startIdleCleanup(sessions, idleTimeoutMs);
+    idleCleanupInterval = startIdleCleanup(
+      sessions,
+      idleTimeoutMs,
+      mcpServerInstance
+    );
   }
   const handleRequest = /* @__PURE__ */ __name(async (c) => {
     const sessionId = c.req.header("mcp-session-id");
@@ -2945,11 +4510,33 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
           context: c,
           honoContext: c
         });
+        server.server.oninitialized = () => {
+          const clientCapabilities = server.server.getClientCapabilities();
+          const clientInfo = server.server.getClientInfo?.() || {};
+          const protocolVersion = server.server.getProtocolVersion?.() || "unknown";
+          if (clientCapabilities && sessions.has(sid)) {
+            const session = sessions.get(sid);
+            session.clientCapabilities = clientCapabilities;
+            console.log(
+              `[MCP] Captured client capabilities for session ${sid}:`,
+              Object.keys(clientCapabilities)
+            );
+          }
+          Telemetry.getInstance().trackServerInitialize({
+            protocolVersion: String(protocolVersion),
+            clientInfo: clientInfo || {},
+            clientCapabilities: clientCapabilities || {},
+            sessionId: sid
+          }).catch(
+            (e) => console.debug(`Failed to track server initialize: ${e}`)
+          );
+        };
       }, "onsessioninitialized"),
       onsessionclosed: /* @__PURE__ */ __name((sid) => {
         console.log(`[MCP] Session closed: ${sid}`);
         transports.delete(sid);
         sessions.delete(sid);
+        mcpServerInstance.cleanupSessionSubscriptions?.(sid);
       }, "onsessionclosed")
     });
     await server.connect(transport);
@@ -3187,12 +4774,13 @@ function createBearerAuthMiddleware(provider, baseUrl) {
       const result = await provider.verifyToken(token);
       const payload = result.payload;
       const user = provider.getUserInfo(payload);
+      const scope = payload.scope;
       const authInfo = {
         user,
         payload,
         accessToken: token,
         // Extract scopes from scope claim (OAuth standard)
-        scopes: payload.scope ? payload.scope.split(" ") : [],
+        scopes: scope ? scope.split(" ") : [],
         // Extract permissions (Auth0 style, or custom)
         permissions: payload.permissions || []
       };
@@ -3240,9 +4828,16 @@ async function setupOAuthForServer(app, oauthProvider, baseUrl, state) {
 __name(setupOAuthForServer, "setupOAuthForServer");
 
 // src/server/mcp-server.ts
-var McpServer = class {
+var MCPServerClass = class {
   static {
-    __name(this, "McpServer");
+    __name(this, "MCPServerClass");
+  }
+  /**
+   * Get the mcp-use package version.
+   * Works in all environments (Node.js, browser, Cloudflare Workers, Deno, etc.)
+   */
+  static getPackageVersion() {
+    return getPackageVersion();
   }
   /**
    * Native MCP server instance from @modelcontextprotocol/sdk
@@ -3266,8 +4861,6 @@ var McpServer = class {
   buildId;
   sessions = /* @__PURE__ */ new Map();
   idleCleanupInterval;
-  oauthConfig;
-  // Store OAuth config for lazy initialization
   oauthSetupState = {
     complete: false,
     provider: void 0,
@@ -3276,15 +4869,37 @@ var McpServer = class {
   oauthProvider;
   oauthMiddleware;
   /**
-   * Storage for registration "recipes" that can be replayed on new server instances
+   * Storage for registrations that can be replayed on new server instances
    * Following the official SDK pattern where each session gets its own server instance
+   * @internal Exposed for telemetry purposes
    */
-  registrationRecipes = {
+  registrations = {
     tools: /* @__PURE__ */ new Map(),
     prompts: /* @__PURE__ */ new Map(),
     resources: /* @__PURE__ */ new Map(),
     resourceTemplates: /* @__PURE__ */ new Map()
   };
+  /**
+   * Storage for widget definitions, used to inject metadata into tool responses
+   * when using the widget() helper with returnsWidget option
+   */
+  widgetDefinitions = /* @__PURE__ */ new Map();
+  /**
+   * Resource subscription manager for tracking and notifying resource updates
+   */
+  subscriptionManager = new ResourceSubscriptionManager();
+  /**
+   * Clean up resource subscriptions for a closed session
+   *
+   * This method is called automatically when a session is closed to remove
+   * all resource subscriptions associated with that session.
+   *
+   * @param sessionId - The session ID to clean up
+   * @internal
+   */
+  cleanupSessionSubscriptions(sessionId) {
+    this.subscriptionManager.cleanupSession(sessionId);
+  }
   /**
    * Creates a new MCP server instance with Hono integration
    *
@@ -3293,23 +4908,34 @@ var McpServer = class {
    * access to Hono methods while preserving MCP server functionality.
    *
    * @param config - Server configuration including name, version, and description
-   * @returns A proxied McpServer instance that supports both MCP and Hono methods
+   * @returns A proxied MCPServer instance that supports both MCP and Hono methods
    */
   constructor(config) {
     this.config = config;
     this.serverHost = config.host || "localhost";
     this.serverBaseUrl = config.baseUrl;
-    this.nativeServer = new import_mcp2.McpServer({
-      name: config.name,
-      version: config.version
-    });
+    this.nativeServer = new import_mcp2.McpServer(
+      {
+        name: config.name,
+        version: config.version
+      },
+      {
+        capabilities: {
+          logging: {},
+          resources: {
+            subscribe: true,
+            listChanged: true
+          }
+        }
+      }
+    );
     this.app = createHonoApp(requestLogger);
-    this.oauthConfig = config.oauth;
+    this.oauthProvider = config.oauth;
     this.wrapRegistrationMethods();
     return createHonoProxy(this, this.app);
   }
   /**
-   * Wrap registration methods to capture recipes following official SDK pattern.
+   * Wrap registration methods to capture registrations following official SDK pattern.
    * Each session will get a fresh server instance with all registrations replayed.
    */
   wrapRegistrationMethods() {
@@ -3319,50 +4945,113 @@ var McpServer = class {
     const originalResourceTemplate = registerResourceTemplate;
     const self = this;
     this.tool = ((toolDefinition, callback) => {
-      const actualCallback = callback || toolDefinition.cb;
-      self.registrationRecipes.tools.set(toolDefinition.name, {
-        config: toolDefinition,
-        handler: actualCallback
-      });
-      return originalTool.call(self, toolDefinition, callback);
+      const widgetConfig = toolDefinition.widget;
+      const widgetName = widgetConfig?.name;
+      if (widgetConfig && widgetName) {
+        const buildIdPart = self.buildId ? `-${self.buildId}` : "";
+        const outputTemplate = `ui://widget/${widgetName}${buildIdPart}.html`;
+        toolDefinition._meta = {
+          ...toolDefinition._meta,
+          "openai/outputTemplate": outputTemplate,
+          "openai/toolInvocation/invoking": widgetConfig.invoking ?? `Loading ${widgetName}...`,
+          "openai/toolInvocation/invoked": widgetConfig.invoked ?? `${widgetName} ready`,
+          "openai/widgetAccessible": widgetConfig.widgetAccessible ?? true,
+          "openai/resultCanProduceWidget": widgetConfig.resultCanProduceWidget ?? true
+        };
+      }
+      let actualCallback = callback || toolDefinition.cb;
+      if (widgetConfig && widgetName && actualCallback) {
+        const originalCallback = actualCallback;
+        actualCallback = /* @__PURE__ */ __name((async (params, ctx) => {
+          const result = await originalCallback(params, ctx);
+          const widgetDef = self.widgetDefinitions.get(widgetName);
+          if (result && typeof result === "object") {
+            const randomId = Math.random().toString(36).substring(2, 15);
+            const buildIdPart = self.buildId ? `-${self.buildId}` : "";
+            const uniqueUri = `ui://widget/${widgetName}${buildIdPart}-${randomId}.html`;
+            const responseMeta = {
+              ...widgetDef || {},
+              // Include mcp-use/widget and other widget metadata
+              "openai/outputTemplate": uniqueUri,
+              "openai/toolInvocation/invoking": widgetConfig.invoking ?? `Loading ${widgetName}...`,
+              "openai/toolInvocation/invoked": widgetConfig.invoked ?? `${widgetName} ready`,
+              "openai/widgetAccessible": widgetConfig.widgetAccessible ?? true,
+              "openai/resultCanProduceWidget": widgetConfig.resultCanProduceWidget ?? true
+            };
+            result._meta = responseMeta;
+            if (result.content?.[0]?.type === "text" && !result.content[0].text) {
+              result.content[0].text = `Displaying ${widgetName}`;
+            }
+          }
+          return result;
+        }), "actualCallback");
+      }
+      if (actualCallback) {
+        self.registrations.tools.set(toolDefinition.name, {
+          config: toolDefinition,
+          handler: actualCallback
+        });
+      }
+      return originalTool.call(self, toolDefinition, actualCallback);
     });
-    this.prompt = function(promptDefinition, callback) {
+    this.prompt = ((promptDefinition, callback) => {
       const actualCallback = callback || promptDefinition.cb;
-      self.registrationRecipes.prompts.set(promptDefinition.name, {
-        config: promptDefinition,
-        handler: actualCallback
-      });
-      return originalPrompt.call(self, promptDefinition, callback);
-    };
-    this.resource = function(resourceDefinition, callback) {
+      if (actualCallback) {
+        self.registrations.prompts.set(promptDefinition.name, {
+          config: promptDefinition,
+          handler: actualCallback
+        });
+      }
+      return originalPrompt.call(
+        self,
+        promptDefinition,
+        callback
+      );
+    });
+    this.resource = ((resourceDefinition, callback) => {
       const actualCallback = callback || resourceDefinition.readCallback;
-      const resourceKey = `${resourceDefinition.name}:${resourceDefinition.uri}`;
-      self.registrationRecipes.resources.set(resourceKey, {
-        config: resourceDefinition,
-        handler: actualCallback
-      });
+      if (actualCallback) {
+        const resourceKey = `${resourceDefinition.name}:${resourceDefinition.uri}`;
+        self.registrations.resources.set(resourceKey, {
+          config: resourceDefinition,
+          handler: actualCallback
+        });
+      }
       return originalResource.call(self, resourceDefinition, callback);
-    };
-    this.resourceTemplate = function(templateDefinition, callback) {
+    });
+    this.resourceTemplate = ((templateDefinition, callback) => {
       const actualCallback = callback || templateDefinition.readCallback;
-      self.registrationRecipes.resourceTemplates.set(templateDefinition.name, {
-        config: templateDefinition,
-        handler: actualCallback
-      });
-      return originalResourceTemplate.call(self, templateDefinition, callback);
-    };
+      if (actualCallback) {
+        self.registrations.resourceTemplates.set(templateDefinition.name, {
+          config: templateDefinition,
+          handler: actualCallback
+        });
+      }
+      return originalResourceTemplate.call(
+        self,
+        templateDefinition,
+        callback
+      );
+    });
   }
   /**
    * Create a new server instance for a session following official SDK pattern.
    * This is called for each initialize request to create an isolated server.
    */
   getServerForSession() {
-    const newServer = new import_mcp2.McpServer({
-      name: this.config.name,
-      version: this.config.version
-    });
-    for (const [name, recipe] of this.registrationRecipes.tools) {
-      const { config, handler: actualCallback } = recipe;
+    const newServer = new import_mcp2.McpServer(
+      {
+        name: this.config.name,
+        version: this.config.version
+      },
+      {
+        capabilities: {
+          logging: {}
+        }
+      }
+    );
+    for (const [name, registration] of this.registrations.tools) {
+      const { config, handler: actualCallback } = registration;
       let inputSchema;
       if (config.schema) {
         inputSchema = this.convertZodSchemaToParams(config.schema);
@@ -3375,12 +5064,21 @@ var McpServer = class {
         const initialRequestContext = getRequestContext();
         const extraProgressToken = extra?._meta?.progressToken;
         const extraSendNotification = extra?.sendNotification;
-        const { requestContext, progressToken, sendNotification: sendNotification2 } = findSessionContext(
+        const { requestContext, session, progressToken, sendNotification: sendNotification2 } = findSessionContext(
           this.sessions,
           initialRequestContext,
           extraProgressToken,
           extraSendNotification
         );
+        let sessionId;
+        if (session) {
+          for (const [id, s] of this.sessions.entries()) {
+            if (s === session) {
+              sessionId = id;
+              break;
+            }
+          }
+        }
         const createMessageWithLogging = /* @__PURE__ */ __name(async (params2, options) => {
           console.log("[createMessage] About to call server.createMessage");
           console.log("[createMessage] Has server:", !!newServer);
@@ -3392,11 +5090,12 @@ var McpServer = class {
             console.log("[createMessage] Got result successfully");
             return result;
           } catch (err) {
+            const error2 = err;
             console.error(
               "[createMessage] Error:",
-              err.message,
+              error2.message,
               "Code:",
-              err.code
+              error2.code
             );
             throw err;
           }
@@ -3406,7 +5105,11 @@ var McpServer = class {
           createMessageWithLogging,
           newServer.server.elicitInput.bind(newServer.server),
           progressToken,
-          sendNotification2
+          sendNotification2,
+          session?.logLevel,
+          session?.clientCapabilities,
+          sessionId,
+          this.sessions
         );
         const executeCallback = /* @__PURE__ */ __name(async () => {
           if (actualCallback.length >= 2) {
@@ -3414,10 +5117,26 @@ var McpServer = class {
           }
           return await actualCallback(params);
         }, "executeCallback");
-        if (requestContext) {
-          return await runWithContext(requestContext, executeCallback);
+        const startTime = Date.now();
+        let success = true;
+        let errorType = null;
+        try {
+          const result = requestContext ? await runWithContext(requestContext, executeCallback) : await executeCallback();
+          return result;
+        } catch (err) {
+          success = false;
+          errorType = err instanceof Error ? err.name : "unknown_error";
+          throw err;
+        } finally {
+          const executionTimeMs = Date.now() - startTime;
+          Telemetry.getInstance().trackServerToolCall({
+            toolName: name,
+            lengthInputArgument: JSON.stringify(params).length,
+            success,
+            errorType,
+            executionTimeMs
+          }).catch((e) => console.debug(`Failed to track tool call: ${e}`));
         }
-        return await executeCallback();
       }, "wrappedHandler");
       newServer.registerTool(
         name,
@@ -3431,21 +5150,38 @@ var McpServer = class {
         wrappedHandler
       );
     }
-    for (const [name, recipe] of this.registrationRecipes.prompts) {
-      const { config, handler } = recipe;
+    for (const [name, registration] of this.registrations.prompts) {
+      const { config, handler } = registration;
       let argsSchema;
       if (config.schema) {
         argsSchema = this.convertZodSchemaToParams(config.schema);
+      } else if (config.args && config.args.length > 0) {
+        argsSchema = this.createParamsSchema(config.args);
       } else {
-        argsSchema = this.createParamsSchema(config.args || []);
+        argsSchema = void 0;
       }
-      const wrappedHandler = /* @__PURE__ */ __name(async (params) => {
-        const result = await handler(params);
-        if ("messages" in result && Array.isArray(result.messages)) {
-          return result;
+      const wrappedHandler = /* @__PURE__ */ __name(async (params, extra) => {
+        let success = true;
+        let errorType = null;
+        try {
+          const result = await handler(params, extra);
+          if ("messages" in result && Array.isArray(result.messages)) {
+            return result;
+          }
+          const { convertToolResultToPromptResult: convertToolResultToPromptResult2 } = await Promise.resolve().then(() => (init_conversion2(), conversion_exports2));
+          return convertToolResultToPromptResult2(result);
+        } catch (err) {
+          success = false;
+          errorType = err instanceof Error ? err.name : "unknown_error";
+          throw err;
+        } finally {
+          Telemetry.getInstance().trackServerPromptCall({
+            name,
+            description: config.description ?? null,
+            success,
+            errorType
+          }).catch((e) => console.debug(`Failed to track prompt call: ${e}`));
         }
-        const { convertToolResultToPromptResult: convertToolResultToPromptResult2 } = await Promise.resolve().then(() => (init_conversion2(), conversion_exports2));
-        return convertToolResultToPromptResult2(result);
       }, "wrappedHandler");
       newServer.registerPrompt(
         name,
@@ -3457,15 +5193,42 @@ var McpServer = class {
         wrappedHandler
       );
     }
-    for (const [_key, recipe] of this.registrationRecipes.resources) {
-      const { config, handler } = recipe;
-      const wrappedHandler = /* @__PURE__ */ __name(async () => {
-        const result = await handler();
-        if ("contents" in result && Array.isArray(result.contents)) {
-          return result;
+    for (const [_key, registration] of this.registrations.resources) {
+      const { config, handler } = registration;
+      const wrappedHandler = /* @__PURE__ */ __name(async (extra) => {
+        let success = true;
+        let errorType = null;
+        let contents = [];
+        try {
+          const result = await handler(extra);
+          if ("contents" in result && Array.isArray(result.contents)) {
+            contents = result.contents;
+            return result;
+          }
+          const { convertToolResultToResourceResult: convertToolResultToResourceResult2 } = await Promise.resolve().then(() => (init_conversion(), conversion_exports));
+          const converted = convertToolResultToResourceResult2(
+            config.uri,
+            result
+          );
+          contents = converted.contents || [];
+          return converted;
+        } catch (err) {
+          success = false;
+          errorType = err instanceof Error ? err.name : "unknown_error";
+          throw err;
+        } finally {
+          Telemetry.getInstance().trackServerResourceCall({
+            name: config.name,
+            description: config.description ?? null,
+            contents: contents.map((c) => ({
+              mime_type: c.mimeType ?? null,
+              text: c.text ? `[text: ${c.text.length} chars]` : null,
+              blob: c.blob ? `[blob: ${c.blob.length} bytes]` : null
+            })),
+            success,
+            errorType
+          }).catch((e) => console.debug(`Failed to track resource call: ${e}`));
         }
-        const { convertToolResultToResourceResult: convertToolResultToResourceResult2 } = await Promise.resolve().then(() => (init_conversion(), conversion_exports));
-        return convertToolResultToResourceResult2(config.uri, result);
       }, "wrappedHandler");
       newServer.registerResource(
         config.name,
@@ -3478,24 +5241,25 @@ var McpServer = class {
         wrappedHandler
       );
     }
-    for (const [_name, recipe] of this.registrationRecipes.resourceTemplates) {
-      const { config, handler } = recipe;
-      const template = new import_mcp2.ResourceTemplate(
-        config.resourceTemplate.uriTemplate,
-        {
-          list: void 0,
-          complete: void 0
-        }
-      );
+    for (const [_name, registration] of this.registrations.resourceTemplates) {
+      const { config, handler } = registration;
+      const isFlatStructure = "uriTemplate" in config;
+      const uriTemplate = isFlatStructure ? config.uriTemplate : config.resourceTemplate.uriTemplate;
+      const mimeType = isFlatStructure ? config.mimeType : config.resourceTemplate.mimeType;
+      const templateDescription = isFlatStructure ? void 0 : config.resourceTemplate.description;
+      const template = new import_mcp2.ResourceTemplate(uriTemplate, {
+        list: void 0,
+        complete: void 0
+      });
       const metadata = {};
       if (config.title) {
         metadata.title = config.title;
       }
-      if (config.description || config.resourceTemplate.description) {
-        metadata.description = config.description || config.resourceTemplate.description;
+      if (config.description || templateDescription) {
+        metadata.description = config.description || templateDescription;
       }
-      if (config.resourceTemplate.mimeType) {
-        metadata.mimeType = config.resourceTemplate.mimeType;
+      if (mimeType) {
+        metadata.mimeType = mimeType;
       }
       if (config.annotations) {
         metadata.annotations = config.annotations;
@@ -3504,20 +5268,90 @@ var McpServer = class {
         config.name,
         template,
         metadata,
-        async (uri) => {
-          const params = this.parseTemplateUri(
-            config.resourceTemplate.uriTemplate,
-            uri.toString()
-          );
-          const result = await handler(uri, params);
-          if ("contents" in result && Array.isArray(result.contents)) {
-            return result;
+        async (uri, extra) => {
+          let success = true;
+          let errorType = null;
+          let contents = [];
+          try {
+            const params = this.parseTemplateUri(uriTemplate, uri.toString());
+            const result = await handler(uri, params, extra);
+            if ("contents" in result && Array.isArray(result.contents)) {
+              contents = result.contents;
+              return result;
+            }
+            const { convertToolResultToResourceResult: convertToolResultToResourceResult2 } = await Promise.resolve().then(() => (init_conversion(), conversion_exports));
+            const converted = convertToolResultToResourceResult2(
+              uri.toString(),
+              result
+            );
+            contents = converted.contents || [];
+            return converted;
+          } catch (err) {
+            success = false;
+            errorType = err instanceof Error ? err.name : "unknown_error";
+            throw err;
+          } finally {
+            Telemetry.getInstance().trackServerResourceCall({
+              name: config.name,
+              description: config.description ?? null,
+              contents: contents.map((c) => ({
+                mimeType: c.mimeType ?? null,
+                text: c.text ? `[text: ${c.text.length} chars]` : null,
+                blob: c.blob ? `[blob: ${c.blob.length} bytes]` : null
+              })),
+              success,
+              errorType
+            }).catch(
+              (e) => console.debug(`Failed to track resource template call: ${e}`)
+            );
           }
-          const { convertToolResultToResourceResult: convertToolResultToResourceResult2 } = await Promise.resolve().then(() => (init_conversion(), conversion_exports));
-          return convertToolResultToResourceResult2(uri.toString(), result);
         }
       );
     }
+    newServer.server.setRequestHandler(
+      import_zod2.z.object({ method: import_zod2.z.literal("logging/setLevel") }).passthrough(),
+      (async (request, extra) => {
+        const level = request.params?.level;
+        if (!level) {
+          throw new import_types2.McpError(
+            import_types2.ErrorCode.InvalidParams,
+            "Missing 'level' parameter"
+          );
+        }
+        if (!isValidLogLevel(level)) {
+          throw new import_types2.McpError(
+            import_types2.ErrorCode.InvalidParams,
+            `Invalid log level '${level}'. Must be one of: debug, info, notice, warning, error, critical, alert, emergency`
+          );
+        }
+        const requestContext = getRequestContext();
+        if (requestContext) {
+          const sessionId = requestContext.req.header("mcp-session-id");
+          if (sessionId && this.sessions.has(sessionId)) {
+            const session = this.sessions.get(sessionId);
+            session.logLevel = level;
+            console.log(
+              `[MCP] Set log level to '${level}' for session ${sessionId}`
+            );
+            return {};
+          }
+        }
+        for (const [sessionId, session] of this.sessions.entries()) {
+          if (session.server === newServer) {
+            session.logLevel = level;
+            console.log(
+              `[MCP] Set log level to '${level}' for session ${sessionId}`
+            );
+            return {};
+          }
+        }
+        console.warn(
+          "[MCP] Could not find session for logging/setLevel request"
+        );
+        throw new import_types2.McpError(import_types2.ErrorCode.InternalError, "Could not find session");
+      })
+    );
+    this.subscriptionManager.registerHandlers(newServer, this.sessions);
     return newServer;
   }
   /**
@@ -3531,23 +5365,43 @@ var McpServer = class {
       this.serverPort
     );
   }
-  // Tool registration helper
-  tool = toolRegistration;
+  // Tool registration helper - type is set in wrapRegistrationMethods
+  tool;
   // Schema conversion helpers (used by tool registration)
   convertZodSchemaToParams = convertZodSchemaToParams;
   createParamsSchema = createParamsSchema;
   // Template URI parsing helper (used by resource templates)
   parseTemplateUri = parseTemplateUri;
-  // Resource registration helpers
-  resource = registerResource;
-  resourceTemplate = registerResourceTemplate;
-  // Prompt registration helper
-  prompt = registerPrompt;
+  // Resource registration helpers - types are set in wrapRegistrationMethods
+  resource;
+  resourceTemplate;
+  // Prompt registration helper - type is set in wrapRegistrationMethods
+  prompt;
   // Notification helpers
   getActiveSessions = getActiveSessions;
   sendNotification = sendNotification;
   sendNotificationToSession = sendNotificationToSession2;
-  uiResource = uiResourceRegistration;
+  /**
+   * Notify subscribed clients that a resource has been updated
+   *
+   * This method sends a `notifications/resources/updated` notification to all
+   * sessions that have subscribed to the specified resource URI.
+   *
+   * @param uri - The URI of the resource that changed
+   * @returns Promise that resolves when all notifications have been sent
+   *
+   * @example
+   * ```typescript
+   * // After updating a resource, notify subscribers
+   * await server.notifyResourceUpdated("file:///path/to/resource.txt");
+   * ```
+   */
+  async notifyResourceUpdated(uri) {
+    return this.subscriptionManager.notifyResourceUpdated(uri, this.sessions);
+  }
+  uiResource = /* @__PURE__ */ __name((definition) => {
+    return uiResourceRegistration(this, definition);
+  }, "uiResource");
   /**
    * Mount MCP server endpoints at /mcp and /sse
    *
@@ -3572,7 +5426,7 @@ var McpServer = class {
     const result = await mountMcp(
       this.app,
       this,
-      // Pass the McpServer instance so mountMcp can call getServerForSession()
+      // Pass the MCPServer instance so mountMcp can call getServerForSession()
       this.sessions,
       this.config,
       isProductionMode()
@@ -3630,7 +5484,12 @@ var McpServer = class {
     if (hostEnv) {
       this.serverHost = hostEnv;
     }
-    if (this.oauthConfig && !this.oauthSetupState.complete) {
+    this.serverBaseUrl = getServerBaseUrl(
+      this.serverBaseUrl,
+      this.serverHost,
+      this.serverPort
+    );
+    if (this.oauthProvider && !this.oauthSetupState.complete) {
       await setupOAuthForServer(
         this.app,
         this.oauthProvider,
@@ -3645,10 +5504,14 @@ var McpServer = class {
     await this.mountMcp();
     await this.mountInspector();
     this.logRegisteredItems();
+    this._trackServerRun("http");
     await startServer(this.app, this.serverPort, this.serverHost, {
       onDenoRequest: rewriteSupabaseRequest
     });
   }
+  _trackServerRun(transport) {
+    Telemetry.getInstance().trackServerRunFromServer(this, transport).catch((e) => console.debug(`Failed to track server run: ${e}`));
+  }
   /**
    * Get the fetch handler for the server after mounting all endpoints
    *
@@ -3667,7 +5530,7 @@ var McpServer = class {
    * @example
    * ```typescript
    * // For Supabase Edge Functions (handles path rewriting automatically)
-   * const server = createMCPServer('my-server');
+   * const server = new MCPServer({ name: 'my-server', version: '1.0.0' });
    * server.tool({ ... });
    * const handler = await server.getHandler({ provider: 'supabase' });
    * Deno.serve(handler);
@@ -3676,14 +5539,14 @@ var McpServer = class {
    * @example
    * ```typescript
    * // For Cloudflare Workers
-   * const server = createMCPServer('my-server');
+   * const server = new MCPServer({ name: 'my-server', version: '1.0.0' });
    * server.tool({ ... });
    * const handler = await server.getHandler();
    * export default { fetch: handler };
    * ```
    */
   async getHandler(options) {
-    if (this.oauthConfig && !this.oauthSetupState.complete) {
+    if (this.oauthProvider && !this.oauthSetupState.complete) {
       await setupOAuthForServer(
         this.app,
         this.oauthProvider,
@@ -3702,6 +5565,8 @@ var McpServer = class {
     console.log("[MCP] Mounting inspector");
     await this.mountInspector();
     console.log("[MCP] Mounted inspector");
+    const provider = options?.provider || "fetch";
+    this._trackServerRun(provider);
     const fetchHandler = this.app.fetch.bind(this.app);
     if (options?.provider === "supabase") {
       return async (req) => {
@@ -3753,8 +5618,9 @@ var McpServer = class {
     }
   }
 };
+var MCPServer = MCPServerClass;
 function createMCPServer(name, config = {}) {
-  const instance = new McpServer({
+  const instance = new MCPServerClass({
     name,
     version: config.version || "1.0.0",
     description: config.description,
@@ -3770,6 +5636,7 @@ function createMCPServer(name, config = {}) {
 __name(createMCPServer, "createMCPServer");
 
 // src/server/index.ts
+init_version();
 init_context_storage();
 
 // src/server/oauth/providers/supabase.ts
@@ -3836,12 +5703,13 @@ var SupabaseOAuthProvider = class {
     }
   }
   getUserInfo(payload) {
+    const userMetadata = payload.user_metadata;
     return {
       userId: payload.sub || payload.user_id,
       email: payload.email,
-      name: payload.user_metadata?.name || payload.user_metadata?.full_name,
-      username: payload.user_metadata?.username,
-      picture: payload.user_metadata?.avatar_url,
+      name: userMetadata?.name || userMetadata?.full_name,
+      username: userMetadata?.username,
+      picture: userMetadata?.avatar_url,
       roles: payload.role ? [payload.role] : [],
       permissions: payload.aal ? [`aal:${payload.aal}`] : [],
       // Include Supabase-specific claims
@@ -3914,6 +5782,7 @@ var Auth0OAuthProvider = class {
     }
   }
   getUserInfo(payload) {
+    const scope = payload.scope;
     return {
       userId: payload.sub,
       email: payload.email,
@@ -3926,7 +5795,7 @@ var Auth0OAuthProvider = class {
       // Auth0 can include roles (if configured)
       roles: payload.roles || payload["https://your-app.com/roles"] || [],
       // Include scope as well
-      scopes: payload.scope ? payload.scope.split(" ") : [],
+      scopes: scope ? scope.split(" ") : [],
       // Additional Auth0-specific claims
       email_verified: payload.email_verified,
       updated_at: payload.updated_at
@@ -3998,8 +5867,10 @@ var KeycloakOAuthProvider = class {
     }
   }
   getUserInfo(payload) {
-    const realmRoles = payload.realm_access?.roles || [];
-    const clientRoles = this.config.clientId && payload.resource_access?.[this.config.clientId]?.roles || [];
+    const realmAccess = payload.realm_access;
+    const realmRoles = realmAccess?.roles || [];
+    const resourceAccess = payload.resource_access;
+    const clientRoles = this.config.clientId && (resourceAccess?.[this.config.clientId]?.roles || []) || [];
     const allRoles = [...realmRoles, ...clientRoles];
     const permissions = [];
     if (payload.resource_access) {
@@ -4013,6 +5884,7 @@ var KeycloakOAuthProvider = class {
         }
       );
     }
+    const scope = payload.scope;
     return {
       userId: payload.sub,
       email: payload.email,
@@ -4023,7 +5895,7 @@ var KeycloakOAuthProvider = class {
       roles: allRoles,
       permissions,
       // Include scope as well
-      scopes: payload.scope ? payload.scope.split(" ") : [],
+      scopes: scope ? scope.split(" ") : [],
       // Keycloak-specific claims
       email_verified: payload.email_verified,
       given_name: payload.given_name,
@@ -4152,7 +6024,7 @@ var CustomOAuthProvider = class {
   async verifyToken(token) {
     try {
       const result = await this.config.verifyToken(token);
-      return { payload: result };
+      return result;
     } catch (error2) {
       throw new Error(`Custom OAuth verification failed: ${error2}`);
     }
@@ -4161,16 +6033,19 @@ var CustomOAuthProvider = class {
     if (this.config.getUserInfo) {
       return this.config.getUserInfo(payload);
     }
+    const scope = payload.scope;
+    const roles = payload.roles;
+    const permissions = payload.permissions;
     return {
       userId: payload.sub || payload.user_id || payload.id,
-      email: payload.email,
-      name: payload.name,
-      username: payload.username || payload.preferred_username,
-      nickname: payload.nickname,
-      picture: payload.picture || payload.avatar_url,
-      roles: payload.roles || [],
-      permissions: payload.permissions || [],
-      scopes: payload.scope ? payload.scope.split(" ") : []
+      email: payload.email ? payload.email : void 0,
+      name: payload.name ? payload.name : void 0,
+      username: payload.username || payload.preferred_username ? payload.username || payload.preferred_username : void 0,
+      nickname: payload.nickname ? payload.nickname : void 0,
+      picture: payload.picture || payload.avatar_url ? payload.picture || payload.avatar_url : void 0,
+      roles: Array.isArray(roles) ? roles : [],
+      permissions: Array.isArray(permissions) ? permissions : [],
+      scopes: scope ? scope.split(" ") : []
     };
   }
   getIssuer() {