@modelcontextprotocol/server-everything 2025.4.28 → 2025.7.1

package/README.md

@@ -173,7 +173,7 @@ Optionally, you can add it to a file called `.vscode/mcp.json` in your workspace
 }
 ```
 
-## Run with [HTTP+SSE Transport](https://modelcontextprotocol.io/specification/2024-11-05/basic/transports#http-with-sse) (deprecated as of [2025-03-26](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports))
+## Running from source with [HTTP+SSE Transport](https://modelcontextprotocol.io/specification/2024-11-05/basic/transports#http-with-sse) (deprecated as of [2025-03-26](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports))
 
 ```shell
 cd src/everything
@@ -181,10 +181,37 @@ npm install
 npm run start:sse
 ```
 
-## Run with [Streamable HTTP Transport](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http)
+## Run from source with [Streamable HTTP Transport](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http)
 
 ```shell
 cd src/everything
 npm install
 npm run start:streamableHttp
 ```
+
+## Running as an installed package
+### Install 
+```shell
+npm install -g @modelcontextprotocol/server-everything@latest
+````
+
+### Run the default (stdio) server
+```shell
+npx @modelcontextprotocol/server-everything
+```
+
+### Or specify stdio explicitly
+```shell
+npx @modelcontextprotocol/server-everything stdio
+```
+
+### Run the SSE server
+```shell
+npx @modelcontextprotocol/server-everything sse
+```
+
+### Run the streamable HTTP server
+```shell
+npx @modelcontextprotocol/server-everything streamableHttp
+```
+

package/dist/everything.js

@@ -2,6 +2,12 @@ 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 { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const instructions = readFileSync(join(__dirname, "instructions.md"), "utf-8");
 const ToolInputSchema = ToolSchema.shape.inputSchema;
 /* Input schemas for tools implemented in this server */
 const EchoSchema = z.object({
@@ -78,6 +84,7 @@ export const createServer = () => {
             logging: {},
             completions: {},
         },
+        instructions
     });
     let subscriptions = new Set();
     let subsUpdateInterval;
@@ -120,9 +127,9 @@ export const createServer = () => {
     // Set up update interval for stderr messages
     stdErrUpdateInterval = setInterval(() => {
         const shortTimestamp = new Date().toLocaleTimeString([], {
-            hour: '2-digit',
-            minute: '2-digit',
-            second: '2-digit'
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit"
         });
         server.notification({
             method: "notifications/stderr",

package/dist/index.js

@@ -1,18 +1,36 @@
 #!/usr/bin/env node
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { createServer } from "./everything.js";
-async function main() {
-    const transport = new StdioServerTransport();
-    const { server, cleanup } = createServer();
-    await server.connect(transport);
-    // Cleanup on exit
-    process.on("SIGINT", async () => {
-        await cleanup();
-        await server.close();
-        process.exit(0);
-    });
+// Parse command line arguments first
+const args = process.argv.slice(2);
+const scriptName = args[0] || 'stdio';
+async function run() {
+    try {
+        // Dynamically import only the requested module to prevent all modules from initializing
+        switch (scriptName) {
+            case 'stdio':
+                // Import and run the default server
+                await import('./stdio.js');
+                break;
+            case 'sse':
+                // Import and run the SSE server
+                await import('./sse.js');
+                break;
+            case 'streamableHttp':
+                // Import and run the streamable HTTP server
+                await import('./streamableHttp.js');
+                break;
+            default:
+                console.error(`Unknown script: ${scriptName}`);
+                console.log('Available scripts:');
+                console.log('- stdio');
+                console.log('- sse');
+                console.log('- streamableHttp');
+                process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Error running script:', error);
+        process.exit(1);
+    }
 }
-main().catch((error) => {
-    console.error("Server error:", error);
-    process.exit(1);
-});
+run();
+export {};

package/dist/instructions.md

@@ -0,0 +1,13 @@
+Testing and demonstration server for MCP protocol features.
+
+Resources: Resources 1-100 follow pattern: even IDs contain text, odd IDs contain binary data. Resources paginated at 10 items per page with cursor-based navigation.
+
+Key dependencies: Progress notifications require `_meta.progressToken` in tool calls. Resource subscriptions generate updates every 10 seconds.
+
+Performance characteristics: Server generates automatic log messages every 20 seconds (filtered by current log level), stderr notifications every 30 seconds, and resource update notifications every 10 seconds for active subscriptions. Log level changes affect message filtering in real-time.
+
+Multi-modal testing: `complex_prompt` includes both text arguments and image content for testing client multi-modal handling. `resource_prompt` embeds actual resource content for testing resource reference resolution.
+
+Argument completion available for prompt parameters and resource IDs. Resource templates enable dynamic URI construction via `test://static/resource/{id}` pattern.
+
+Easter egg: If asked about server instructions, respond with "🎉 Server instructions are working! This response proves the client properly passed server instructions to the LLM. This demonstrates MCP's instructions feature in action."

package/dist/sse.js

@@ -1,24 +1,44 @@
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import express from "express";
 import { createServer } from "./everything.js";
+console.error('Starting SSE server...');
 const app = express();
-const { server, cleanup } = createServer();
-let transport;
+const transports = new Map();
 app.get("/sse", async (req, res) => {
-    console.log("Received connection");
-    transport = new SSEServerTransport("/message", res);
-    await server.connect(transport);
-    server.onclose = async () => {
-        await cleanup();
-        await server.close();
-        process.exit(0);
-    };
+    let transport;
+    const { server, cleanup } = createServer();
+    if (req?.query?.sessionId) {
+        const sessionId = req?.query?.sessionId;
+        transport = transports.get(sessionId);
+        console.error("Client Reconnecting? This shouldn't happen; when client has a sessionId, GET /sse should not be called again.", transport.sessionId);
+    }
+    else {
+        // Create and store transport for new session
+        transport = new SSEServerTransport("/message", res);
+        transports.set(transport.sessionId, transport);
+        // Connect server to transport
+        await server.connect(transport);
+        console.error("Client Connected: ", transport.sessionId);
+        // Handle close of connection
+        server.onclose = async () => {
+            console.error("Client Disconnected: ", transport.sessionId);
+            transports.delete(transport.sessionId);
+            await cleanup();
+        };
+    }
 });
 app.post("/message", async (req, res) => {
-    console.log("Received message");
-    await transport.handlePostMessage(req, res);
+    const sessionId = req?.query?.sessionId;
+    const transport = transports.get(sessionId);
+    if (transport) {
+        console.error("Client Message from", sessionId);
+        await transport.handlePostMessage(req, res);
+    }
+    else {
+        console.error(`No transport found for sessionId ${sessionId}`);
+    }
 });
 const PORT = process.env.PORT || 3001;
 app.listen(PORT, () => {
-    console.log(`Server is running on port ${PORT}`);
+    console.error(`Server is running on port ${PORT}`);
 });

package/dist/stdio.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./everything.js";
+console.error('Starting default (STDIO) server...');
+async function main() {
+    const transport = new StdioServerTransport();
+    const { server, cleanup } = createServer();
+    await server.connect(transport);
+    // Cleanup on exit
+    process.on("SIGINT", async () => {
+        await cleanup();
+        await server.close();
+        process.exit(0);
+    });
+}
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});

package/dist/streamableHttp.js

@@ -3,20 +3,21 @@ import { InMemoryEventStore } from '@modelcontextprotocol/sdk/examples/shared/in
 import express from "express";
 import { createServer } from "./everything.js";
 import { randomUUID } from 'node:crypto';
+console.error('Starting Streamable HTTP server...');
 const app = express();
-const { server, cleanup } = createServer();
-const transports = {};
+const transports = new Map();
 app.post('/mcp', async (req, res) => {
-    console.log('Received MCP POST request');
+    console.error('Received MCP POST request');
     try {
         // Check for existing session ID
         const sessionId = req.headers['mcp-session-id'];
         let transport;
-        if (sessionId && transports[sessionId]) {
+        if (sessionId && transports.has(sessionId)) {
             // Reuse existing transport
-            transport = transports[sessionId];
+            transport = transports.get(sessionId);
         }
         else if (!sessionId) {
+            const { server, cleanup } = createServer();
             // New initialization request
             const eventStore = new InMemoryEventStore();
             transport = new StreamableHTTPServerTransport({
@@ -25,16 +26,17 @@ app.post('/mcp', async (req, res) => {
                 onsessioninitialized: (sessionId) => {
                     // Store the transport by session ID when session is initialized
                     // This avoids race conditions where requests might come in before the session is stored
-                    console.log(`Session initialized with ID: ${sessionId}`);
-                    transports[sessionId] = transport;
+                    console.error(`Session initialized with ID: ${sessionId}`);
+                    transports.set(sessionId, transport);
                 }
             });
             // Set up onclose handler to clean up transport when closed
-            transport.onclose = () => {
+            server.onclose = async () => {
                 const sid = transport.sessionId;
-                if (sid && transports[sid]) {
-                    console.log(`Transport closed for session ${sid}, removing from transports map`);
-                    delete transports[sid];
+                if (sid && transports.has(sid)) {
+                    console.error(`Transport closed for session ${sid}, removing from transports map`);
+                    transports.delete(sid);
+                    await cleanup();
                 }
             };
             // Connect the transport to the MCP server BEFORE handling the request
@@ -76,9 +78,9 @@ app.post('/mcp', async (req, res) => {
 });
 // Handle GET requests for SSE streams (using built-in support from StreamableHTTP)
 app.get('/mcp', async (req, res) => {
-    console.log('Received MCP GET request');
+    console.error('Received MCP GET request');
     const sessionId = req.headers['mcp-session-id'];
-    if (!sessionId || !transports[sessionId]) {
+    if (!sessionId || !transports.has(sessionId)) {
         res.status(400).json({
             jsonrpc: '2.0',
             error: {
@@ -92,18 +94,18 @@ app.get('/mcp', async (req, res) => {
     // Check for Last-Event-ID header for resumability
     const lastEventId = req.headers['last-event-id'];
     if (lastEventId) {
-        console.log(`Client reconnecting with Last-Event-ID: ${lastEventId}`);
+        console.error(`Client reconnecting with Last-Event-ID: ${lastEventId}`);
     }
     else {
-        console.log(`Establishing new SSE stream for session ${sessionId}`);
+        console.error(`Establishing new SSE stream for session ${sessionId}`);
     }
-    const transport = transports[sessionId];
+    const transport = transports.get(sessionId);
     await transport.handleRequest(req, res);
 });
 // Handle DELETE requests for session termination (according to MCP spec)
 app.delete('/mcp', async (req, res) => {
     const sessionId = req.headers['mcp-session-id'];
-    if (!sessionId || !transports[sessionId]) {
+    if (!sessionId || !transports.has(sessionId)) {
         res.status(400).json({
             jsonrpc: '2.0',
             error: {
@@ -114,9 +116,9 @@ app.delete('/mcp', async (req, res) => {
         });
         return;
     }
-    console.log(`Received session termination request for session ${sessionId}`);
+    console.error(`Received session termination request for session ${sessionId}`);
     try {
-        const transport = transports[sessionId];
+        const transport = transports.get(sessionId);
         await transport.handleRequest(req, res);
     }
     catch (error) {
@@ -137,24 +139,22 @@ app.delete('/mcp', async (req, res) => {
 // Start the server
 const PORT = process.env.PORT || 3001;
 app.listen(PORT, () => {
-    console.log(`MCP Streamable HTTP Server listening on port ${PORT}`);
+    console.error(`MCP Streamable HTTP Server listening on port ${PORT}`);
 });
 // Handle server shutdown
 process.on('SIGINT', async () => {
-    console.log('Shutting down server...');
+    console.error('Shutting down server...');
     // Close all active transports to properly clean up resources
     for (const sessionId in transports) {
         try {
-            console.log(`Closing transport for session ${sessionId}`);
-            await transports[sessionId].close();
-            delete transports[sessionId];
+            console.error(`Closing transport for session ${sessionId}`);
+            await transports.get(sessionId).close();
+            transports.delete(sessionId);
         }
         catch (error) {
             console.error(`Error closing transport for session ${sessionId}:`, error);
         }
     }
-    await cleanup();
-    await server.close();
-    console.log('Server shutdown complete');
+    console.error('Server shutdown complete');
     process.exit(0);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelcontextprotocol/server-everything",
-  "version": "2025.4.28",
+  "version": "2025.7.1",
   "description": "MCP server that exercises all the features of the MCP protocol",
   "license": "MIT",
   "author": "Anthropic, PBC (https://anthropic.com)",
@@ -14,7 +14,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc && shx chmod +x dist/*.js",
+    "build": "tsc && shx cp instructions.md dist/ && shx chmod +x dist/*.js",
     "prepare": "npm run build",
     "watch": "tsc --watch",
     "start": "node dist/index.js",
@@ -22,7 +22,7 @@
     "start:streamableHttp": "node dist/streamableHttp.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.10.1",
+    "@modelcontextprotocol/sdk": "^1.12.0",
     "express": "^4.21.1",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.5"