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

package/dist/src/server/index.cjs

@@ -126,14 +126,18 @@ var init_runtime = __esm({
 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 +150,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 +179,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) {
@@ -418,7 +426,97 @@ 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, logger) => {
+    if (!shouldLogMessage(level, minLogLevel)) {
+      return;
+    }
+    await sendNotification2({
+      method: "notifications/message",
+      params: {
+        level,
+        data: message,
+        logger: logger || "tool"
+      }
+    });
+  };
+}
+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,9 +528,27 @@ 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";
@@ -446,6 +562,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 +785,11 @@ var init_conversion2 = __esm({
 // src/server/index.ts
 var server_exports = {};
 __export(server_exports, {
+  MCPServer: () => MCPServer,
   adaptConnectMiddleware: () => adaptConnectMiddleware,
   adaptMiddleware: () => adaptMiddleware,
   array: () => array,
+  audio: () => audio,
   binary: () => binary,
   buildWidgetUrl: () => buildWidgetUrl,
   createExternalUrlResource: () => createExternalUrlResource,
@@ -684,11 +828,14 @@ module.exports = __toCommonJS(server_exports);
 
 // src/server/mcp-server.ts
 var import_mcp2 = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_types2 = require("@modelcontextprotocol/sdk/types.js");
+var import_zod2 = require("zod");
 
 // src/server/widgets/index.ts
 init_runtime();
 
 // src/server/utils/response-helpers.ts
+init_runtime();
 function text(content) {
   return {
     content: [
@@ -719,7 +866,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: {
@@ -998,7 +1247,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 "([^/]+)";
   });
@@ -2431,7 +2680,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 +2691,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) {
@@ -2467,6 +2718,152 @@ init_tool_execution_helpers();
 // src/server/resources/index.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 init_conversion();
+
+// src/server/resources/subscriptions.ts
+var import_types = require("@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 +2922,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 +2950,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 +2965,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 +3001,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 +3287,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 +3305,7 @@ function startIdleCleanup(sessions, idleTimeoutMs) {
       );
       for (const sessionId of expiredSessions) {
         sessions.delete(sessionId);
+        mcpServerInstance?.cleanupSessionSubscriptions?.(sessionId);
       }
     }
   }, 6e4);
@@ -2918,7 +3320,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");
@@ -2945,11 +3351,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);
@@ -3240,9 +3658,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
@@ -3285,6 +3703,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
    *
@@ -3293,16 +3727,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 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.wrapRegistrationMethods();
@@ -3357,10 +3802,17 @@ var McpServer = class {
    * 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
-    });
+    const newServer = new import_mcp2.McpServer(
+      {
+        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;
@@ -3375,12 +3827,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);
@@ -3406,7 +3867,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) {
@@ -3436,8 +3901,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);
@@ -3480,22 +3947,23 @@ var McpServer = class {
     }
     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
-        }
-      );
+      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;
@@ -3505,10 +3973,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;
@@ -3518,6 +3983,50 @@ var McpServer = class {
         }
       );
     }
+    newServer.server.setRequestHandler(
+      import_zod2.z.object({ method: import_zod2.z.literal("logging/setLevel") }).passthrough(),
+      async (request) => {
+        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;
   }
   /**
@@ -3547,6 +4056,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
@@ -3572,7 +4099,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,6 +4157,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,
@@ -3667,7 +4199,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,7 +4208,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 };
@@ -3754,7 +4286,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,