@modelcontextprotocol/server-everything 2025.8.18 → 2025.9.12

package/README.md

@@ -89,6 +89,13 @@ This MCP server attempts to exercise all the features of the MCP protocol. It is
      - `structuredContent` field conformant to the output schema
      - A backward compatible Text Content field, a SHOULD advisory in the specification
 
+11. `listRoots`
+   - Lists the current MCP roots provided by the client
+   - Demonstrates the roots protocol capability even though this server doesn't access files
+   - No inputs required
+   - Returns: List of current roots with their URIs and names, or a message if no roots are set
+   - Shows how servers can interact with the MCP roots protocol
+
 ### Resources
 
 The server provides 100 test resources in two formats:
@@ -117,7 +124,7 @@ Resource features:
 2. `complex_prompt`
    - Advanced prompt demonstrating argument handling
    - Required arguments:
-     - `temperature` (number): Temperature setting
+     - `temperature` (string): Temperature setting
    - Optional arguments:
      - `style` (string): Output style preference
    - Returns: Multi-turn conversation with images
@@ -129,6 +136,18 @@ Resource features:
    - Returns: Multi-turn conversation with an embedded resource reference
    - Shows how to include resources directly in prompt messages
 
+### Roots
+
+The server demonstrates the MCP roots protocol capability:
+
+- Declares `roots: { listChanged: true }` capability to indicate support for roots
+- Handles `roots/list_changed` notifications from clients
+- Requests initial roots during server initialization
+- Provides a `listRoots` tool to display current roots
+- Logs roots-related events for demonstration purposes
+
+Note: This server doesn't actually access files, but demonstrates how servers can interact with the roots protocol for clients that need to understand which directories are available for file operations.
+
 ### Logging
 
 The server sends random-leveled log messages every 15 seconds, e.g.:

package/dist/everything.js

@@ -1,5 +1,5 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { CallToolRequestSchema, CompleteRequestSchema, CreateMessageResultSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, SetLevelRequestSchema, SubscribeRequestSchema, ToolSchema, UnsubscribeRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, CompleteRequestSchema, CreateMessageResultSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, RootsListChangedNotificationSchema, SubscribeRequestSchema, ToolSchema, UnsubscribeRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { readFileSync } from "fs";
@@ -62,6 +62,7 @@ const GetResourceLinksSchema = z.object({
         .default(3)
         .describe("Number of resource links to return (1-10)"),
 });
+const ListRootsSchema = z.object({});
 const StructuredContentSchema = {
     input: z.object({
         location: z
@@ -95,6 +96,7 @@ var ToolName;
     ToolName["ELICITATION"] = "startElicitation";
     ToolName["GET_RESOURCE_LINKS"] = "getResourceLinks";
     ToolName["STRUCTURED_CONTENT"] = "structuredContent";
+    ToolName["LIST_ROOTS"] = "listRoots";
 })(ToolName || (ToolName = {}));
 var PromptName;
 (function (PromptName) {
@@ -119,33 +121,23 @@ export const createServer = () => {
             resources: { subscribe: true },
             tools: {},
             logging: {},
-            completions: {},
-            elicitation: {},
+            completions: {}
         },
         instructions
     });
     let subscriptions = new Set();
     let subsUpdateInterval;
     let stdErrUpdateInterval;
-    let logLevel = "debug";
     let logsUpdateInterval;
-    const messages = [
-        { level: "debug", data: "Debug-level message" },
-        { level: "info", data: "Info-level message" },
-        { level: "notice", data: "Notice-level message" },
-        { level: "warning", data: "Warning-level message" },
-        { level: "error", data: "Error-level message" },
-        { level: "critical", data: "Critical-level message" },
-        { level: "alert", data: "Alert level-message" },
-        { level: "emergency", data: "Emergency-level message" },
-    ];
-    const isMessageIgnored = (level) => {
-        const currentLevel = messages.findIndex((msg) => logLevel === msg.level);
-        const messageLevel = messages.findIndex((msg) => level === msg.level);
-        return messageLevel < currentLevel;
-    };
+    // Store client capabilities
+    let clientCapabilities;
+    // Roots state management
+    let currentRoots = [];
+    let clientSupportsRoots = false;
+    let sessionId;
     // Function to start notification intervals when a client connects
-    const startNotificationIntervals = () => {
+    const startNotificationIntervals = (sid) => {
+        sessionId = sid;
         if (!subsUpdateInterval) {
             subsUpdateInterval = setInterval(() => {
                 for (const uri of subscriptions) {
@@ -156,15 +148,22 @@ export const createServer = () => {
                 }
             }, 10000);
         }
+        const maybeAppendSessionId = sessionId ? ` - SessionId ${sessionId}` : "";
+        const messages = [
+            { level: "debug", data: `Debug-level message${maybeAppendSessionId}` },
+            { level: "info", data: `Info-level message${maybeAppendSessionId}` },
+            { level: "notice", data: `Notice-level message${maybeAppendSessionId}` },
+            { level: "warning", data: `Warning-level message${maybeAppendSessionId}` },
+            { level: "error", data: `Error-level message${maybeAppendSessionId}` },
+            { level: "critical", data: `Critical-level message${maybeAppendSessionId}` },
+            { level: "alert", data: `Alert level-message${maybeAppendSessionId}` },
+            { level: "emergency", data: `Emergency-level message${maybeAppendSessionId}` },
+        ];
         if (!logsUpdateInterval) {
-            logsUpdateInterval = setInterval(() => {
-                let message = {
-                    method: "notifications/message",
-                    params: messages[Math.floor(Math.random() * messages.length)],
-                };
-                if (!isMessageIgnored(message.params.level))
-                    server.notification(message);
-            }, 20000);
+            console.error("Starting logs update interval");
+            logsUpdateInterval = setInterval(async () => {
+                await server.sendLoggingMessage(messages[Math.floor(Math.random() * messages.length)], sessionId);
+            }, 15000);
         }
     };
     // Helper method to request sampling from client
@@ -425,11 +424,6 @@ export const createServer = () => {
                 description: "Returns a resource reference that can be used by MCP clients",
                 inputSchema: zodToJsonSchema(GetResourceReferenceSchema),
             },
-            {
-                name: ToolName.ELICITATION,
-                description: "Demonstrates the Elicitation feature by asking the user to provide information about their favorite color, number, and pets.",
-                inputSchema: zodToJsonSchema(ElicitationSchema),
-            },
             {
                 name: ToolName.GET_RESOURCE_LINKS,
                 description: "Returns multiple resource links that reference different types of resources",
@@ -442,9 +436,21 @@ export const createServer = () => {
                 outputSchema: zodToJsonSchema(StructuredContentSchema.output),
             },
         ];
+        if (clientCapabilities.roots)
+            tools.push({
+                name: ToolName.LIST_ROOTS,
+                description: "Lists the current MCP roots provided by the client. Demonstrates the roots protocol capability even though this server doesn't access files.",
+                inputSchema: zodToJsonSchema(ListRootsSchema),
+            });
+        if (clientCapabilities.elicitation)
+            tools.push({
+                name: ToolName.ELICITATION,
+                description: "Demonstrates the Elicitation feature by asking the user to provide information about their favorite color, number, and pets.",
+                inputSchema: zodToJsonSchema(ElicitationSchema),
+            });
         return { tools };
     });
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         const { name, arguments: args } = request.params;
         if (name === ToolName.ECHO) {
             const validatedArgs = EchoSchema.parse(args);
@@ -479,7 +485,7 @@ export const createServer = () => {
                             total: steps,
                             progressToken,
                         },
-                    });
+                    }, { relatedRequestId: extra.requestId });
                 }
             }
             return {
@@ -692,6 +698,47 @@ export const createServer = () => {
                 structuredContent: weather
             };
         }
+        if (name === ToolName.LIST_ROOTS) {
+            ListRootsSchema.parse(args);
+            if (!clientSupportsRoots) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "The MCP client does not support the roots protocol.\n\n" +
+                                "This means the server cannot access information about the client's workspace directories or file system roots."
+                        }
+                    ]
+                };
+            }
+            if (currentRoots.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "The client supports roots but no roots are currently configured.\n\n" +
+                                "This could mean:\n" +
+                                "1. The client hasn't provided any roots yet\n" +
+                                "2. The client provided an empty roots list\n" +
+                                "3. The roots configuration is still being loaded"
+                        }
+                    ]
+                };
+            }
+            const rootsList = currentRoots.map((root, index) => {
+                return `${index + 1}. ${root.name || 'Unnamed Root'}\n   URI: ${root.uri}`;
+            }).join('\n\n');
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Current MCP Roots (${currentRoots.length} total):\n\n${rootsList}\n\n` +
+                            "Note: This server demonstrates the roots protocol capability but doesn't actually access files. " +
+                            "The roots are provided by the MCP client and can be used by servers that need file system access."
+                    }
+                ]
+            };
+        }
         throw new Error(`Unknown tool: ${name}`);
     });
     server.setRequestHandler(CompleteRequestSchema, async (request) => {
@@ -714,20 +761,68 @@ export const createServer = () => {
         }
         throw new Error(`Unknown reference type`);
     });
-    server.setRequestHandler(SetLevelRequestSchema, async (request) => {
-        const { level } = request.params;
-        logLevel = level;
-        // Demonstrate different log levels
-        await server.notification({
-            method: "notifications/message",
-            params: {
-                level: "debug",
-                logger: "test-server",
-                data: `Logging level set to: ${logLevel}`,
-            },
-        });
-        return {};
+    // Roots protocol handlers
+    server.setNotificationHandler(RootsListChangedNotificationSchema, async () => {
+        try {
+            // Request the updated roots list from the client
+            const response = await server.listRoots();
+            if (response && 'roots' in response) {
+                currentRoots = response.roots;
+                // Log the roots update for demonstration
+                await server.sendLoggingMessage({
+                    level: "info",
+                    logger: "everything-server",
+                    data: `Roots updated: ${currentRoots.length} root(s) received from client`,
+                }, sessionId);
+            }
+        }
+        catch (error) {
+            await server.sendLoggingMessage({
+                level: "error",
+                logger: "everything-server",
+                data: `Failed to request roots from client: ${error instanceof Error ? error.message : String(error)}`,
+            }, sessionId);
+        }
     });
+    // Handle post-initialization setup for roots
+    server.oninitialized = async () => {
+        clientCapabilities = server.getClientCapabilities();
+        if (clientCapabilities?.roots) {
+            clientSupportsRoots = true;
+            try {
+                const response = await server.listRoots();
+                if (response && 'roots' in response) {
+                    currentRoots = response.roots;
+                    await server.sendLoggingMessage({
+                        level: "info",
+                        logger: "everything-server",
+                        data: `Initial roots received: ${currentRoots.length} root(s) from client`,
+                    }, sessionId);
+                }
+                else {
+                    await server.sendLoggingMessage({
+                        level: "warning",
+                        logger: "everything-server",
+                        data: "Client returned no roots set",
+                    }, sessionId);
+                }
+            }
+            catch (error) {
+                await server.sendLoggingMessage({
+                    level: "error",
+                    logger: "everything-server",
+                    data: `Failed to request initial roots from client: ${error instanceof Error ? error.message : String(error)}`,
+                }, sessionId);
+            }
+        }
+        else {
+            await server.sendLoggingMessage({
+                level: "info",
+                logger: "everything-server",
+                data: "Client does not support MCP roots protocol",
+            }, sessionId);
+        }
+    };
     const cleanup = async () => {
         if (subsUpdateInterval)
             clearInterval(subsUpdateInterval);

package/dist/sse.js

@@ -20,7 +20,7 @@ app.get("/sse", async (req, res) => {
         await server.connect(transport);
         console.error("Client Connected: ", transport.sessionId);
         // Start notification intervals after client connects
-        startNotificationIntervals();
+        startNotificationIntervals(transport.sessionId);
         // Handle close of connection
         server.onclose = async () => {
             console.error("Client Disconnected: ", transport.sessionId);

package/dist/stdio.js

@@ -4,8 +4,9 @@ import { createServer } from "./everything.js";
 console.error('Starting default (STDIO) server...');
 async function main() {
     const transport = new StdioServerTransport();
-    const { server, cleanup } = createServer();
+    const { server, cleanup, startNotificationIntervals } = createServer();
     await server.connect(transport);
+    startNotificationIntervals();
     // Cleanup on exit
     process.on("SIGINT", async () => {
         await cleanup();

package/dist/streamableHttp.js

@@ -17,7 +17,7 @@ app.post('/mcp', async (req, res) => {
             transport = transports.get(sessionId);
         }
         else if (!sessionId) {
-            const { server, cleanup } = createServer();
+            const { server, cleanup, startNotificationIntervals } = createServer();
             // New initialization request
             const eventStore = new InMemoryEventStore();
             transport = new StreamableHTTPServerTransport({
@@ -43,6 +43,8 @@ app.post('/mcp', async (req, res) => {
             // so responses can flow back through the same transport
             await server.connect(transport);
             await transport.handleRequest(req, res);
+            // Wait until initialize is complete and transport will have a sessionId
+            startNotificationIntervals(transport.sessionId);
             return; // Already handled
         }
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelcontextprotocol/server-everything",
-  "version": "2025.8.18",
+  "version": "2025.9.12",
   "description": "MCP server that exercises all the features of the MCP protocol",
   "license": "MIT",
   "author": "Anthropic, PBC (https://anthropic.com)",
@@ -22,7 +22,7 @@
     "start:streamableHttp": "node dist/streamableHttp.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@modelcontextprotocol/sdk": "^1.18.0",
     "express": "^4.21.1",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.5"