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

package/dist/src/server/index.js

@@ -7,7 +7,7 @@ import {
   createEnhancedContext,
   findSessionContext,
   isValidLogLevel
-} from "../../chunk-33U4IA4N.js";
+} from "../../chunk-BPP5XYP6.js";
 import {
   convertToolResultToResourceResult
 } from "../../chunk-362PI25Z.js";
@@ -16,13 +16,17 @@ import {
 } from "../../chunk-2EYAMIT3.js";
 import "../../chunk-KUEVOU4M.js";
 import {
+  Telemetry,
+  VERSION,
   fsHelpers,
   generateUUID,
   getCwd,
   getEnv,
+  getPackageVersion,
   isDeno,
   pathHelpers
-} from "../../chunk-MTHLLDCX.js";
+} from "../../chunk-6EYDSXO6.js";
+import "../../chunk-34R6SIER.js";
 import {
   __name
 } from "../../chunk-3GQAWCBQ.js";
@@ -31,8 +35,11 @@ import {
 import {
   McpServer as OfficialMcpServer,
   ResourceTemplate as ResourceTemplate2
-} from "@modelcontextprotocol/sdk/server/mcp.js";
-import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+} from "@mcp-use/modelcontextprotocol-sdk/server/mcp.js";
+import {
+  McpError,
+  ErrorCode
+} from "@mcp-use/modelcontextprotocol-sdk/types.js";
 import { z as z2 } from "zod";
 
 // src/server/utils/response-helpers.ts
@@ -307,37 +314,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
@@ -1006,6 +988,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,
@@ -1021,7 +1004,8 @@ function createWidgetRegistration(widgetName, metadata, html2, serverConfig, isD
         type: "appsSdk",
         props,
         html: html2,
-        dev: isDev
+        dev: isDev,
+        exposeAsTool
       },
       ...metadata._meta || {}
     },
@@ -1301,10 +1285,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)
@@ -1325,12 +1341,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
@@ -1587,25 +1606,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:
@@ -1614,12 +1639,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,
@@ -1641,9 +1666,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,
@@ -1668,70 +1693,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");
 
@@ -1867,7 +1899,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,
@@ -1878,7 +1910,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) {
@@ -1898,13 +1932,13 @@ function toolRegistration(toolDefinition, callback) {
 __name(toolRegistration, "toolRegistration");
 
 // src/server/resources/index.ts
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ResourceTemplate } from "@mcp-use/modelcontextprotocol-sdk/server/mcp.js";
 
 // src/server/resources/subscriptions.ts
 import {
   SubscribeRequestSchema,
   UnsubscribeRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
+} from "@mcp-use/modelcontextprotocol-sdk/types.js";
 var ResourceSubscriptionManager = class {
   static {
     __name(this, "ResourceSubscriptionManager");
@@ -2057,7 +2091,7 @@ function registerResource(resourceDefinition, callback) {
   const explicitMimeType = resourceDefinition.mimeType;
   const wrappedCallback = /* @__PURE__ */ __name(async () => {
     const { getRequestContext: getRequestContext2, runWithContext: runWithContext2 } = await import("../../context-storage-NA4MHWOZ.js");
-    const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-BQJTPWPN.js");
+    const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-XFVBSRXM.js");
     const initialRequestContext = getRequestContext2();
     const sessions = this.sessions || /* @__PURE__ */ new Map();
     const { requestContext } = findSessionContext2(
@@ -2105,24 +2139,25 @@ function registerResourceTemplate(resourceTemplateDefinition, callback) {
       `Resource template '${resourceTemplateDefinition.name}' must have either a readCallback property or a callback parameter`
     );
   }
-  const template = new 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 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;
@@ -2132,12 +2167,9 @@ 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 import("../../context-storage-NA4MHWOZ.js");
-      const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-BQJTPWPN.js");
+      const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-XFVBSRXM.js");
       const initialRequestContext = getRequestContext2();
       const sessions = this.sessions || /* @__PURE__ */ new Map();
       const { requestContext } = findSessionContext2(
@@ -2150,8 +2182,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)) {
@@ -2188,7 +2224,7 @@ function registerPrompt(promptDefinition, callback) {
   }
   const wrappedCallback = /* @__PURE__ */ __name(async (params, extra) => {
     const { getRequestContext: getRequestContext2, runWithContext: runWithContext2 } = await import("../../context-storage-NA4MHWOZ.js");
-    const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-BQJTPWPN.js");
+    const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-XFVBSRXM.js");
     const initialRequestContext = getRequestContext2();
     const sessions = this.sessions || /* @__PURE__ */ new Map();
     const { requestContext } = findSessionContext2(
@@ -2486,7 +2522,7 @@ __name(startIdleCleanup, "startIdleCleanup");
 
 // src/server/endpoints/mount-mcp.ts
 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;
@@ -2522,6 +2558,27 @@ 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}`);
@@ -2765,12 +2822,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 || []
       };
@@ -2818,9 +2876,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
@@ -2844,8 +2909,6 @@ var McpServer = class {
   buildId;
   sessions = /* @__PURE__ */ new Map();
   idleCleanupInterval;
-  oauthConfig;
-  // Store OAuth config for lazy initialization
   oauthSetupState = {
     complete: false,
     provider: void 0,
@@ -2854,15 +2917,21 @@ 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
    */
@@ -2887,7 +2956,7 @@ 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;
@@ -2909,12 +2978,12 @@ var McpServer = class {
       }
     );
     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() {
@@ -2924,38 +2993,94 @@ 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.
@@ -2973,8 +3098,8 @@ var McpServer = class {
         }
       }
     );
-    for (const [name, recipe] of this.registrationRecipes.tools) {
-      const { config, handler: actualCallback } = recipe;
+    for (const [name, registration] of this.registrations.tools) {
+      const { config, handler: actualCallback } = registration;
       let inputSchema;
       if (config.schema) {
         inputSchema = this.convertZodSchemaToParams(config.schema);
@@ -2993,6 +3118,15 @@ var McpServer = class {
           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);
@@ -3004,11 +3138,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;
           }
@@ -3019,7 +3154,10 @@ var McpServer = class {
           newServer.server.elicitInput.bind(newServer.server),
           progressToken,
           sendNotification2,
-          session?.logLevel
+          session?.logLevel,
+          session?.clientCapabilities,
+          sessionId,
+          this.sessions
         );
         const executeCallback = /* @__PURE__ */ __name(async () => {
           if (actualCallback.length >= 2) {
@@ -3027,10 +3165,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,
@@ -3044,8 +3198,8 @@ 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);
@@ -3054,13 +3208,28 @@ var McpServer = class {
       } else {
         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 import("../../conversion-OTRZZBUU.js");
+          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 import("../../conversion-OTRZZBUU.js");
-        return convertToolResultToPromptResult2(result);
       }, "wrappedHandler");
       newServer.registerPrompt(
         name,
@@ -3072,15 +3241,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 import("../../conversion-5MA4VY3B.js");
+          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 import("../../conversion-5MA4VY3B.js");
-        return convertToolResultToResourceResult2(config.uri, result);
       }, "wrappedHandler");
       newServer.registerResource(
         config.name,
@@ -3093,24 +3289,25 @@ var McpServer = class {
         wrappedHandler
       );
     }
-    for (const [_name, recipe] of this.registrationRecipes.resourceTemplates) {
-      const { config, handler } = recipe;
-      const template = new ResourceTemplate2(
-        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 ResourceTemplate2(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;
@@ -3119,23 +3316,49 @@ 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 import("../../conversion-5MA4VY3B.js");
+            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 import("../../conversion-5MA4VY3B.js");
-          return convertToolResultToResourceResult2(uri.toString(), result);
         }
       );
     }
     newServer.server.setRequestHandler(
       z2.object({ method: z2.literal("logging/setLevel") }).passthrough(),
-      async (request) => {
+      (async (request, extra) => {
         const level = request.params?.level;
         if (!level) {
           throw new McpError(
@@ -3174,7 +3397,7 @@ var McpServer = class {
           "[MCP] Could not find session for logging/setLevel request"
         );
         throw new McpError(ErrorCode.InternalError, "Could not find session");
-      }
+      })
     );
     this.subscriptionManager.registerHandlers(newServer, this.sessions);
     return newServer;
@@ -3190,18 +3413,18 @@ 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;
@@ -3224,7 +3447,9 @@ var McpServer = class {
   async notifyResourceUpdated(uri) {
     return this.subscriptionManager.notifyResourceUpdated(uri, this.sessions);
   }
-  uiResource = uiResourceRegistration;
+  uiResource = /* @__PURE__ */ __name((definition) => {
+    return uiResourceRegistration(this, definition);
+  }, "uiResource");
   /**
    * Mount MCP server endpoints at /mcp and /sse
    *
@@ -3249,7 +3474,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()
@@ -3312,7 +3537,7 @@ var McpServer = class {
       this.serverHost,
       this.serverPort
     );
-    if (this.oauthConfig && !this.oauthSetupState.complete) {
+    if (this.oauthProvider && !this.oauthSetupState.complete) {
       await setupOAuthForServer(
         this.app,
         this.oauthProvider,
@@ -3327,10 +3552,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
    *
@@ -3349,7 +3578,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);
@@ -3358,14 +3587,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,
@@ -3384,6 +3613,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) => {
@@ -3435,8 +3666,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,
@@ -3520,12 +3752,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
@@ -3598,6 +3831,7 @@ var Auth0OAuthProvider = class {
     }
   }
   getUserInfo(payload) {
+    const scope = payload.scope;
     return {
       userId: payload.sub,
       email: payload.email,
@@ -3610,7 +3844,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
@@ -3682,8 +3916,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) {
@@ -3697,6 +3933,7 @@ var KeycloakOAuthProvider = class {
         }
       );
     }
+    const scope = payload.scope;
     return {
       userId: payload.sub,
       email: payload.email,
@@ -3707,7 +3944,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,
@@ -3836,7 +4073,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}`);
     }
@@ -3845,16 +4082,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() {
@@ -4039,6 +4279,8 @@ function requireAnyScope(needed) {
 }
 __name(requireAnyScope, "requireAnyScope");
 export {
+  MCPServer,
+  VERSION,
   adaptConnectMiddleware,
   adaptMiddleware,
   array,
@@ -4053,6 +4295,7 @@ export {
   css,
   error,
   getAuth,
+  getPackageVersion,
   getRequestContext,
   hasAnyScope,
   hasRequestContext,