Add setLevel handling to Server when logging capability is advertised. Update sendLoggingMessage method to respect current log level.

Add sendLoggingMessage passthrough method on McpServer class since it doesn't use inheritance.

Update examples to use the sendLoggingMessage method so that it can be filtered according to the log level.

* In src/server/index.ts
  - in constructor
    - if capabilities object has logging, set request handler for SetLevelRequestSchema which sets this.logLevel to the level value from the request params and return empty object as per spec
  - define private _logLevel property of type LoggingLevel initialized to "debug"
  - define private _msgLevels property with list of objects with level property set to the ascending logging levels according to RFC 5424 as per spec. This gives us a lookup to determine if level is greater or less than a target level
  - add private isMessageIgnored method which takes a LoggingLevel type arg returns boolean, and looks up the currently set level and the target level, returning true if the target level is below the current level
  - in sendLoggingMessage method, only send the notification if the params.level value is not ignored.

* In mcp.ts
  - import LoggingMessageNotification
  - add async sendLoggingMessage method that returns takes a params object from LoggingMessageNotification, and returns the result of a call to this.server.sendLoggingMessage (since McpServer doesn't extend Server, but rather uses composition.

* In src/examples/server/
  - jsonResponseStreamableHttp.ts
  - simpleSseServer.ts
  - simpleStreamableHttp.ts
  - simpleStatelessStreamableHttp.ts
    - in tool call callback functions that send logging message via the included sendNotification function, replace with calls to server.sendLoggingMessage, passing only the params of the message.

Author: cliffhall

src/examples/server/jsonResponseStreamableHttp.ts

@@ -44,26 +44,26 @@ const getServer = () => {
     {
       name: z.string().describe('Name to greet'),
     },
-    async ({ name }, { sendNotification }): Promise<CallToolResult> => {
+    async ({ name }): Promise<CallToolResult> => {
       const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
 
-      await sendNotification({
-        method: "notifications/message",
-        params: { level: "debug", data: `Starting multi-greet for ${name}` }
+      await server.sendLoggingMessage({
+        level: "debug",
+        data: `Starting multi-greet for ${name}`
       });
 
       await sleep(1000); // Wait 1 second before first greeting
 
-      await sendNotification({
-        method: "notifications/message",
-        params: { level: "info", data: `Sending first greeting to ${name}` }
+      await server.sendLoggingMessage({
+        level: "info",
+        data: `Sending first greeting to ${name}`
       });
 
       await sleep(1000); // Wait another second before second greeting
 
-      await sendNotification({
-        method: "notifications/message",
-        params: { level: "info", data: `Sending second greeting to ${name}` }
+      await server.sendLoggingMessage({
+        level: "info",
+        data: `Sending second greeting to ${name}`
       });
 
       return {
@@ -170,4 +170,4 @@ app.listen(PORT, (error) => {
 process.on('SIGINT', async () => {
   console.log('Shutting down server...');
   process.exit(0);
-});
+});

src/examples/server/simpleSseServer.ts

@@ -5,13 +5,13 @@ import { z } from 'zod';
 import { CallToolResult } from '../../types.js';
 
 /**
- * This example server demonstrates the deprecated HTTP+SSE transport 
+ * This example server demonstrates the deprecated HTTP+SSE transport
  * (protocol version 2024-11-05). It mainly used for testing backward compatible clients.
- * 
+ *
  * The server exposes two endpoints:
  * - /mcp: For establishing the SSE stream (GET)
  * - /messages: For receiving client messages (POST)
- * 
+ *
  */
 
 // Create an MCP server instance
@@ -28,17 +28,14 @@ const getServer = () => {
       interval: z.number().describe('Interval in milliseconds between notifications').default(1000),
       count: z.number().describe('Number of notifications to send').default(10),
     },
-    async ({ interval, count }, { sendNotification }): Promise<CallToolResult> => {
+    async ({ interval, count }): Promise<CallToolResult> => {
       const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
       let counter = 0;
 
       // Send the initial notification
-      await sendNotification({
-        method: "notifications/message",
-        params: {
-          level: "info",
-          data: `Starting notification stream with ${count} messages every ${interval}ms`
-        }
+      await server.sendLoggingMessage({
+        level: "info",
+        data: `Starting notification stream with ${count} messages every ${interval}ms`
       });
 
       // Send periodic notifications
@@ -47,13 +44,10 @@ const getServer = () => {
         await sleep(interval);
 
         try {
-          await sendNotification({
-            method: "notifications/message",
-            params: {
+            await server.sendLoggingMessage({
               level: "info",
               data: `Notification #${counter} at ${new Date().toISOString()}`
-            }
-          });
+            });
         }
         catch (error) {
           console.error("Error sending notification:", error);
@@ -169,4 +163,4 @@ process.on('SIGINT', async () => {
   }
   console.log('Server shutdown complete');
   process.exit(0);
-});
+});

src/examples/server/simpleStatelessStreamableHttp.ts

@@ -42,19 +42,16 @@ const getServer = () => {
       interval: z.number().describe('Interval in milliseconds between notifications').default(100),
       count: z.number().describe('Number of notifications to send (0 for 100)').default(10),
     },
-    async ({ interval, count }, { sendNotification }): Promise<CallToolResult> => {
+    async ({ interval, count }): Promise<CallToolResult> => {
       const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
       let counter = 0;
 
       while (count === 0 || counter < count) {
         counter++;
         try {
-          await sendNotification({
-            method: "notifications/message",
-            params: {
-              level: "info",
-              data: `Periodic notification #${counter} at ${new Date().toISOString()}`
-            }
+          await server.sendLoggingMessage({
+            level: "info",
+            data: `Periodic notification #${counter} at ${new Date().toISOString()}`
           });
         }
         catch (error) {
@@ -170,4 +167,4 @@ app.listen(PORT, (error) => {
 process.on('SIGINT', async () => {
   console.log('Shutting down server...');
   process.exit(0);
-});
+});

src/examples/server/simpleStreamableHttp.ts

@@ -58,27 +58,18 @@ const getServer = () => {
       readOnlyHint: true,
       openWorldHint: false
     },
-    async ({ name }, { sendNotification }): Promise<CallToolResult> => {
+    async ({ name }): Promise<CallToolResult> => {
       const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
 
-      await sendNotification({
-        method: "notifications/message",
-        params: { level: "debug", data: `Starting multi-greet for ${name}` }
-      });
+      await server.sendLoggingMessage({ level: "debug", data: `Starting multi-greet for ${name}`});
 
       await sleep(1000); // Wait 1 second before first greeting
 
-      await sendNotification({
-        method: "notifications/message",
-        params: { level: "info", data: `Sending first greeting to ${name}` }
-      });
+      await server.sendLoggingMessage( { level: "info", data: `Sending first greeting to ${name}`});
 
       await sleep(1000); // Wait another second before second greeting
 
-      await sendNotification({
-        method: "notifications/message",
-        params: { level: "info", data: `Sending second greeting to ${name}` }
-      });
+      await server.sendLoggingMessage( { level: "info", data: `Sending second greeting to ${name}`});
 
       return {
         content: [
@@ -273,20 +264,17 @@ const getServer = () => {
       interval: z.number().describe('Interval in milliseconds between notifications').default(100),
       count: z.number().describe('Number of notifications to send (0 for 100)').default(50),
     },
-    async ({ interval, count }, { sendNotification }): Promise<CallToolResult> => {
+    async ({ interval, count }): Promise<CallToolResult> => {
       const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
       let counter = 0;
 
       while (count === 0 || counter < count) {
         counter++;
         try {
-          await sendNotification({
-            method: "notifications/message",
-            params: {
-              level: "info",
-              data: `Periodic notification #${counter} at ${new Date().toISOString()}`
-            }
-          });
+            await server.sendLoggingMessage( {
+                level: "info",
+                data: `Periodic notification #${counter} at ${new Date().toISOString()}`
+            });
         }
         catch (error) {
           console.error("Error sending notification:", error);

src/examples/server/sseAndStreamableHttpCompatibleServer.ts

@@ -12,7 +12,7 @@ import cors from 'cors';
  * This example server demonstrates backwards compatibility with both:
  * 1. The deprecated HTTP+SSE transport (protocol version 2024-11-05)
  * 2. The Streamable HTTP transport (protocol version 2025-03-26)
- * 
+ *
  * It maintains a single MCP server instance but exposes two transport options:
  * - /mcp: The new Streamable HTTP endpoint (supports GET/POST/DELETE)
  * - /sse: The deprecated SSE endpoint for older clients (GET to establish stream)
@@ -33,19 +33,16 @@ const getServer = () => {
       interval: z.number().describe('Interval in milliseconds between notifications').default(100),
       count: z.number().describe('Number of notifications to send (0 for 100)').default(50),
     },
-    async ({ interval, count }, { sendNotification }): Promise<CallToolResult> => {
+    async ({ interval, count }): Promise<CallToolResult> => {
       const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
       let counter = 0;
 
       while (count === 0 || counter < count) {
         counter++;
         try {
-          await sendNotification({
-            method: "notifications/message",
-            params: {
-              level: "info",
-              data: `Periodic notification #${counter} at ${new Date().toISOString()}`
-            }
+          await server.sendLoggingMessage({
+            level: "info",
+            data: `Periodic notification #${counter} at ${new Date().toISOString()}`
           });
         }
         catch (error) {
@@ -254,4 +251,4 @@ process.on('SIGINT', async () => {
   }
   console.log('Server shutdown complete');
   process.exit(0);
-});
+});

src/server/index.ts

@@ -32,6 +32,7 @@ import {
   ServerRequest,
   ServerResult,
   SUPPORTED_PROTOCOL_VERSIONS,
+  LoggingLevel, SetLevelRequestSchema,
 } from "../types.js";
 import Ajv from "ajv";
 
@@ -108,8 +109,34 @@ export class Server<
     this.setNotificationHandler(InitializedNotificationSchema, () =>
       this.oninitialized?.(),
     );
+
+    if (this._capabilities.logging) {
+        this.setRequestHandler(SetLevelRequestSchema, async (request) => {
+            const { level } = request.params;
+            this._logLevel = level;
+            return {};
+        })
+    }
   }
 
+  private _logLevel: LoggingLevel = "debug";
+  private _msgLevels = [
+    { level: "debug" },
+    { level: "info" },
+    { level: "notice" },
+    { level: "warning" },
+    { level: "error"  },
+    { level: "critical" },
+    { level: "alert" },
+    { level: "emergency" },
+  ];
+
+  private isMessageIgnored = (level: LoggingLevel): boolean => {
+    const currentLevel = this._msgLevels.findIndex((msg) => this._logLevel === msg.level);
+    const messageLevel = this._msgLevels.findIndex((msg) => level === msg.level);
+    return messageLevel < currentLevel;
+  };
+
   /**
    * Registers new capabilities. This can only be called before connecting to a transport.
    *
@@ -121,7 +148,6 @@ export class Server<
         "Cannot register capabilities after connecting to transport",
       );
     }
-
     this._capabilities = mergeCapabilities(this._capabilities, capabilities);
   }
 
@@ -324,10 +350,10 @@ export class Server<
     if (result.action === "accept" && result.content) {
       try {
         const ajv = new Ajv();
-        
+
         const validate = ajv.compile(params.requestedSchema);
         const isValid = validate(result.content);
-        
+
         if (!isValid) {
           throw new McpError(
             ErrorCode.InvalidParams,
@@ -360,7 +386,9 @@ export class Server<
   }
 
   async sendLoggingMessage(params: LoggingMessageNotification["params"]) {
-    return this.notification({ method: "notifications/message", params });
+      return (!this.isMessageIgnored(params.level))
+        ? this.notification({ method: "notifications/message", params })
+        : undefined
   }
 
   async sendResourceUpdated(params: ResourceUpdatedNotification["params"]) {

src/server/mcp.ts

@@ -41,6 +41,7 @@ import {
   ServerRequest,
   ServerNotification,
   ToolAnnotations,
+  LoggingMessageNotification,
 } from "../types.js";
 import { Completable, CompletableDef } from "./completable.js";
 import { UriTemplate, Variables } from "../shared/uriTemplate.js";
@@ -822,7 +823,7 @@ export class McpServer {
   /**
    * Registers a tool taking either a parameter schema for validation or annotations for additional metadata.
    * This unified overload handles both `tool(name, paramsSchema, cb)` and `tool(name, annotations, cb)` cases.
-   * 
+   *
    * Note: We use a union type for the second parameter because TypeScript cannot reliably disambiguate
    * between ToolAnnotations and ZodRawShape during overload resolution, as both are plain object types.
    */
@@ -834,9 +835,9 @@ export class McpServer {
 
   /**
    * Registers a tool `name` (with a description) taking either parameter schema or annotations.
-   * This unified overload handles both `tool(name, description, paramsSchema, cb)` and 
+   * This unified overload handles both `tool(name, description, paramsSchema, cb)` and
    * `tool(name, description, annotations, cb)` cases.
-   * 
+   *
    * Note: We use a union type for the third parameter because TypeScript cannot reliably disambiguate
    * between ToolAnnotations and ZodRawShape during overload resolution, as both are plain object types.
    */
@@ -1047,6 +1048,15 @@ export class McpServer {
     return this.server.transport !== undefined
   }
 
+  /**
+   * Sends a logging message to the client, if connected.
+   * Note: You only need to send the parameters object
+   * @see LoggingMessageNotification
+   * @param params
+   */
+  async sendLoggingMessage(params: LoggingMessageNotification["params"]) {
+    return this.server.sendLoggingMessage(params);
+  }
   /**
    * Sends a resource list changed event to the client, if connected.
    */