@modelcontextprotocol/server-everything 2025.8.4 → 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.:
@@ -169,22 +188,24 @@ For quick installation, use of of the one-click install buttons below...
 
 [![Install with Docker in VS Code](https://img.shields.io/badge/VS_Code-Docker-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=everything&config=%7B%22command%22%3A%22docker%22%2C%22args%22%3A%5B%22run%22%2C%22-i%22%2C%22--rm%22%2C%22mcp%2Feverything%22%5D%7D) [![Install with Docker in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Docker-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=everything&config=%7B%22command%22%3A%22docker%22%2C%22args%22%3A%5B%22run%22%2C%22-i%22%2C%22--rm%22%2C%22mcp%2Feverything%22%5D%7D&quality=insiders)
 
-For manual installation, add the following JSON block to your User Settings (JSON) file in VS Code. You can do this by pressing `Ctrl + Shift + P` and typing `Preferences: Open User Settings (JSON)`.
+For manual installation, you can configure the MCP server using one of these methods:
+
+**Method 1: User Configuration (Recommended)**
+Add the configuration to your user-level MCP configuration file. Open the Command Palette (`Ctrl + Shift + P`) and run `MCP: Open User Configuration`. This will open your user `mcp.json` file where you can add the server configuration.
 
-Optionally, you can add it to a file called `.vscode/mcp.json` in your workspace. This will allow you to share the configuration with others.
+**Method 2: Workspace Configuration**
+Alternatively, you can add the configuration to a file called `.vscode/mcp.json` in your workspace. This will allow you to share the configuration with others.
 
-> Note that the `mcp` key is not needed in the `.vscode/mcp.json` file.
+> For more details about MCP configuration in VS Code, see the [official VS Code MCP documentation](https://code.visualstudio.com/docs/copilot/mcp).
 
 #### NPX
 
 ```json
 {
-  "mcp": {
-    "servers": {
-      "everything": {
-        "command": "npx",
-        "args": ["-y", "@modelcontextprotocol/server-everything"]
-      }
+  "servers": {
+    "everything": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-everything"]
     }
   }
 }

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,49 +121,51 @@ export const createServer = () => {
             resources: { subscribe: true },
             tools: {},
             logging: {},
-            completions: {},
-            elicitation: {},
+            completions: {}
         },
         instructions
     });
     let subscriptions = new Set();
     let subsUpdateInterval;
     let stdErrUpdateInterval;
-    // Set up update interval for subscribed resources
-    subsUpdateInterval = setInterval(() => {
-        for (const uri of subscriptions) {
-            server.notification({
-                method: "notifications/resources/updated",
-                params: { uri },
-            });
-        }
-    }, 10000);
-    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 = (sid) => {
+        sessionId = sid;
+        if (!subsUpdateInterval) {
+            subsUpdateInterval = setInterval(() => {
+                for (const uri of subscriptions) {
+                    server.notification({
+                        method: "notifications/resources/updated",
+                        params: { uri },
+                    });
+                }
+            }, 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) {
+            console.error("Starting logs update interval");
+            logsUpdateInterval = setInterval(async () => {
+                await server.sendLoggingMessage(messages[Math.floor(Math.random() * messages.length)], sessionId);
+            }, 15000);
+        }
     };
-    // Set up update interval for random log messages
-    logsUpdateInterval = setInterval(() => {
-        let message = {
-            method: "notifications/message",
-            params: messages[Math.floor(Math.random() * messages.length)],
-        };
-        if (!isMessageIgnored(message.params.level))
-            server.notification(message);
-    }, 20000);
     // Helper method to request sampling from client
     const requestSampling = async (context, uri, maxTokens = 100) => {
         const request = {
@@ -420,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",
@@ -437,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);
@@ -474,7 +485,7 @@ export const createServer = () => {
                             total: steps,
                             progressToken,
                         },
-                    });
+                    }, { relatedRequestId: extra.requestId });
                 }
             }
             return {
@@ -687,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) => {
@@ -709,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);
@@ -731,6 +831,6 @@ export const createServer = () => {
         if (stdErrUpdateInterval)
             clearInterval(stdErrUpdateInterval);
     };
-    return { server, cleanup };
+    return { server, cleanup, startNotificationIntervals };
 };
 const MCP_TINY_IMAGE = "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";

package/dist/sse.js

@@ -6,7 +6,7 @@ const app = express();
 const transports = new Map();
 app.get("/sse", async (req, res) => {
     let transport;
-    const { server, cleanup } = createServer();
+    const { server, cleanup, startNotificationIntervals } = createServer();
     if (req?.query?.sessionId) {
         const sessionId = req?.query?.sessionId;
         transport = transports.get(sessionId);
@@ -19,6 +19,8 @@ app.get("/sse", async (req, res) => {
         // Connect server to transport
         await server.connect(transport);
         console.error("Client Connected: ", transport.sessionId);
+        // Start notification intervals after client connects
+        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.4",
+  "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"