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

package/dist/src/server/index.js

@@ -2,11 +2,12 @@ import {
   getRequestContext,
   hasRequestContext,
   runWithContext
-} from "../../chunk-5URNFWCQ.js";
+} from "../../chunk-LWVK6RXA.js";
 import {
   createEnhancedContext,
-  findSessionContext
-} from "../../chunk-KHTTBIRP.js";
+  findSessionContext,
+  isValidLogLevel
+} from "../../chunk-Q3PFK7Y4.js";
 import {
   convertToolResultToResourceResult
 } from "../../chunk-362PI25Z.js";
@@ -31,6 +32,8 @@ import {
   McpServer as OfficialMcpServer,
   ResourceTemplate as ResourceTemplate2
 } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import { z as z2 } from "zod";
 
 // src/server/utils/response-helpers.ts
 function text(content) {
@@ -63,7 +66,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: {
@@ -338,7 +443,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 "([^/]+)";
   });
@@ -1762,7 +1867,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,
@@ -1773,7 +1878,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) {
@@ -1794,6 +1901,154 @@ __name(toolRegistration, "toolRegistration");
 
 // src/server/resources/index.ts
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/server/resources/subscriptions.ts
+import {
+  SubscribeRequestSchema,
+  UnsubscribeRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+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(
+      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(
+      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) {
@@ -1803,8 +2058,8 @@ function registerResource(resourceDefinition, callback) {
   }
   const explicitMimeType = resourceDefinition.mimeType;
   const wrappedCallback = /* @__PURE__ */ __name(async () => {
-    const { getRequestContext: getRequestContext2, runWithContext: runWithContext2 } = await import("../../context-storage-TXQ4DVSS.js");
-    const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-IVUDHXMK.js");
+    const { getRequestContext: getRequestContext2, runWithContext: runWithContext2 } = await import("../../context-storage-NA4MHWOZ.js");
+    const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-RRMGLAHR.js");
     const initialRequestContext = getRequestContext2();
     const sessions = this.sessions || /* @__PURE__ */ new Map();
     const { requestContext } = findSessionContext2(
@@ -1852,24 +2107,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;
@@ -1879,12 +2135,9 @@ function registerResourceTemplate(resourceTemplateDefinition, callback) {
     template,
     metadata,
     async (uri) => {
-      const params = this.parseTemplateUri(
-        resourceTemplateDefinition.resourceTemplate.uriTemplate,
-        uri.toString()
-      );
-      const { getRequestContext: getRequestContext2, runWithContext: runWithContext2 } = await import("../../context-storage-TXQ4DVSS.js");
-      const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-IVUDHXMK.js");
+      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-RRMGLAHR.js");
       const initialRequestContext = getRequestContext2();
       const sessions = this.sessions || /* @__PURE__ */ new Map();
       const { requestContext } = findSessionContext2(
@@ -1897,8 +2150,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)) {
@@ -1928,12 +2185,14 @@ 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 import("../../context-storage-TXQ4DVSS.js");
-    const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-IVUDHXMK.js");
+    const { getRequestContext: getRequestContext2, runWithContext: runWithContext2 } = await import("../../context-storage-NA4MHWOZ.js");
+    const { findSessionContext: findSessionContext2 } = await import("../../tool-execution-helpers-RRMGLAHR.js");
     const initialRequestContext = getRequestContext2();
     const sessions = this.sessions || /* @__PURE__ */ new Map();
     const { requestContext } = findSessionContext2(
@@ -2204,7 +2463,7 @@ async function sendNotificationToSession2(sessionId, method, params) {
 __name(sendNotificationToSession2, "sendNotificationToSession");
 
 // src/server/sessions/session-manager.ts
-function startIdleCleanup(sessions, idleTimeoutMs) {
+function startIdleCleanup(sessions, idleTimeoutMs, mcpServerInstance) {
   if (idleTimeoutMs <= 0) {
     return void 0;
   }
@@ -2222,6 +2481,7 @@ function startIdleCleanup(sessions, idleTimeoutMs) {
       );
       for (const sessionId of expiredSessions) {
         sessions.delete(sessionId);
+        mcpServerInstance?.cleanupSessionSubscriptions?.(sessionId);
       }
     }
   }, 6e4);
@@ -2235,7 +2495,11 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
   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");
@@ -2262,11 +2526,23 @@ async function mountMcp(app, mcpServerInstance, sessions, config, isProductionMo
           context: c,
           honoContext: c
         });
+        server.server.oninitialized = () => {
+          const clientCapabilities = server.server.getClientCapabilities();
+          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)
+            );
+          }
+        };
       }, "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);
@@ -2557,9 +2833,9 @@ async function setupOAuthForServer(app, oauthProvider, baseUrl, state) {
 __name(setupOAuthForServer, "setupOAuthForServer");
 
 // src/server/mcp-server.ts
-var McpServer = class {
+var MCPServer = class {
   static {
-    __name(this, "McpServer");
+    __name(this, "MCPServer");
   }
   /**
    * Native MCP server instance from @modelcontextprotocol/sdk
@@ -2602,6 +2878,22 @@ var McpServer = class {
     resources: /* @__PURE__ */ new Map(),
     resourceTemplates: /* @__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
    *
@@ -2610,16 +2902,27 @@ 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 OfficialMcpServer({
-      name: config.name,
-      version: config.version
-    });
+    this.nativeServer = new OfficialMcpServer(
+      {
+        name: config.name,
+        version: config.version
+      },
+      {
+        capabilities: {
+          logging: {},
+          resources: {
+            subscribe: true,
+            listChanged: true
+          }
+        }
+      }
+    );
     this.app = createHonoApp(requestLogger);
     this.oauthConfig = config.oauth;
     this.wrapRegistrationMethods();
@@ -2674,10 +2977,17 @@ var McpServer = class {
    * This is called for each initialize request to create an isolated server.
    */
   getServerForSession() {
-    const newServer = new OfficialMcpServer({
-      name: this.config.name,
-      version: this.config.version
-    });
+    const newServer = new OfficialMcpServer(
+      {
+        name: this.config.name,
+        version: this.config.version
+      },
+      {
+        capabilities: {
+          logging: {}
+        }
+      }
+    );
     for (const [name, recipe] of this.registrationRecipes.tools) {
       const { config, handler: actualCallback } = recipe;
       let inputSchema;
@@ -2692,12 +3002,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);
@@ -2723,7 +3042,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) {
@@ -2753,8 +3076,10 @@ var McpServer = class {
       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);
@@ -2797,22 +3122,23 @@ var McpServer = class {
     }
     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
-        }
-      );
+      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;
@@ -2822,10 +3148,7 @@ var McpServer = class {
         template,
         metadata,
         async (uri) => {
-          const params = this.parseTemplateUri(
-            config.resourceTemplate.uriTemplate,
-            uri.toString()
-          );
+          const params = this.parseTemplateUri(uriTemplate, uri.toString());
           const result = await handler(uri, params);
           if ("contents" in result && Array.isArray(result.contents)) {
             return result;
@@ -2835,6 +3158,50 @@ var McpServer = class {
         }
       );
     }
+    newServer.server.setRequestHandler(
+      z2.object({ method: z2.literal("logging/setLevel") }).passthrough(),
+      async (request) => {
+        const level = request.params?.level;
+        if (!level) {
+          throw new McpError(
+            ErrorCode.InvalidParams,
+            "Missing 'level' parameter"
+          );
+        }
+        if (!isValidLogLevel(level)) {
+          throw new McpError(
+            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 McpError(ErrorCode.InternalError, "Could not find session");
+      }
+    );
+    this.subscriptionManager.registerHandlers(newServer, this.sessions);
     return newServer;
   }
   /**
@@ -2864,6 +3231,24 @@ var McpServer = class {
   getActiveSessions = getActiveSessions;
   sendNotification = sendNotification;
   sendNotificationToSession = sendNotificationToSession2;
+  /**
+   * 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 = uiResourceRegistration;
   /**
    * Mount MCP server endpoints at /mcp and /sse
@@ -2889,7 +3274,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()
@@ -2947,6 +3332,11 @@ var McpServer = class {
     if (hostEnv) {
       this.serverHost = hostEnv;
     }
+    this.serverBaseUrl = getServerBaseUrl(
+      this.serverBaseUrl,
+      this.serverHost,
+      this.serverPort
+    );
     if (this.oauthConfig && !this.oauthSetupState.complete) {
       await setupOAuthForServer(
         this.app,
@@ -2984,7 +3374,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);
@@ -2993,7 +3383,7 @@ 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 };
@@ -3071,7 +3461,7 @@ var McpServer = class {
   }
 };
 function createMCPServer(name, config = {}) {
-  const instance = new McpServer({
+  const instance = new MCPServer({
     name,
     version: config.version || "1.0.0",
     description: config.description,
@@ -3674,9 +4064,11 @@ function requireAnyScope(needed) {
 }
 __name(requireAnyScope, "requireAnyScope");
 export {
+  MCPServer,
   adaptConnectMiddleware,
   adaptMiddleware,
   array,
+  audio,
   binary,
   buildWidgetUrl,
   createExternalUrlResource,