@modelcontextprotocol/server-everything 2025.12.18 → 2026.1.14

package/dist/{streamableHttp.js → transports/streamableHttp.js}

@@ -1,71 +1,68 @@
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { InMemoryEventStore } from '@modelcontextprotocol/sdk/examples/shared/inMemoryEventStore.js';
+import { InMemoryEventStore } from "@modelcontextprotocol/sdk/examples/shared/inMemoryEventStore.js";
 import express from "express";
-import { createServer } from "./everything.js";
-import { randomUUID } from 'node:crypto';
-import cors from 'cors';
-console.error('Starting Streamable HTTP server...');
+import { createServer } from "../server/index.js";
+import { randomUUID } from "node:crypto";
+import cors from "cors";
+console.log("Starting Streamable HTTP server...");
+// Express app with permissive CORS for testing with Inspector direct connect mode
 const app = express();
 app.use(cors({
-    "origin": "*", // use "*" with caution in production
-    "methods": "GET,POST,DELETE",
-    "preflightContinue": false,
-    "optionsSuccessStatus": 204,
-    "exposedHeaders": [
-        'mcp-session-id',
-        'last-event-id',
-        'mcp-protocol-version'
-    ]
-})); // Enable CORS for all routes so Inspector can connect
+    origin: "*", // use "*" with caution in production
+    methods: "GET,POST,DELETE",
+    preflightContinue: false,
+    optionsSuccessStatus: 204,
+    exposedHeaders: ["mcp-session-id", "last-event-id", "mcp-protocol-version"],
+}));
+// Map sessionId to server transport for each client
 const transports = new Map();
-app.post('/mcp', async (req, res) => {
-    console.error('Received MCP POST request');
+// Handle POST requests for client messages
+app.post("/mcp", async (req, res) => {
+    console.log("Received MCP POST request");
     try {
         // Check for existing session ID
-        const sessionId = req.headers['mcp-session-id'];
+        const sessionId = req.headers["mcp-session-id"];
         let transport;
         if (sessionId && transports.has(sessionId)) {
             // Reuse existing transport
             transport = transports.get(sessionId);
         }
         else if (!sessionId) {
-            const { server, cleanup, startNotificationIntervals } = createServer();
+            const { server, cleanup } = createServer();
             // New initialization request
             const eventStore = new InMemoryEventStore();
             transport = new StreamableHTTPServerTransport({
                 sessionIdGenerator: () => randomUUID(),
                 eventStore, // Enable resumability
                 onsessioninitialized: (sessionId) => {
-                    // Store the transport by session ID when session is initialized
+                    // Store the transport by session ID when a session is initialized
                     // This avoids race conditions where requests might come in before the session is stored
-                    console.error(`Session initialized with ID: ${sessionId}`);
+                    console.log(`Session initialized with ID: ${sessionId}`);
                     transports.set(sessionId, transport);
-                }
+                },
             });
             // Set up onclose handler to clean up transport when closed
-            server.onclose = async () => {
+            server.server.onclose = async () => {
                 const sid = transport.sessionId;
                 if (sid && transports.has(sid)) {
-                    console.error(`Transport closed for session ${sid}, removing from transports map`);
+                    console.log(`Transport closed for session ${sid}, removing from transports map`);
                     transports.delete(sid);
-                    await cleanup();
+                    cleanup(sid);
                 }
             };
             // Connect the transport to the MCP server BEFORE handling the request
             // 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
+            return;
         }
         else {
             // Invalid request - no session ID or not initialization request
             res.status(400).json({
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 error: {
                     code: -32000,
-                    message: 'Bad Request: No valid session ID provided',
+                    message: "Bad Request: No valid session ID provided",
                 },
                 id: req?.body?.id,
             });
@@ -76,13 +73,13 @@ app.post('/mcp', async (req, res) => {
         await transport.handleRequest(req, res);
     }
     catch (error) {
-        console.error('Error handling MCP request:', error);
+        console.log("Error handling MCP request:", error);
         if (!res.headersSent) {
             res.status(500).json({
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 error: {
                     code: -32603,
-                    message: 'Internal server error',
+                    message: "Internal server error",
                 },
                 id: req?.body?.id,
             });
@@ -90,59 +87,59 @@ 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.error('Received MCP GET request');
-    const sessionId = req.headers['mcp-session-id'];
+// Handle GET requests for SSE streams
+app.get("/mcp", async (req, res) => {
+    console.log("Received MCP GET request");
+    const sessionId = req.headers["mcp-session-id"];
     if (!sessionId || !transports.has(sessionId)) {
         res.status(400).json({
-            jsonrpc: '2.0',
+            jsonrpc: "2.0",
             error: {
                 code: -32000,
-                message: 'Bad Request: No valid session ID provided',
+                message: "Bad Request: No valid session ID provided",
             },
             id: req?.body?.id,
         });
         return;
     }
     // Check for Last-Event-ID header for resumability
-    const lastEventId = req.headers['last-event-id'];
+    const lastEventId = req.headers["last-event-id"];
     if (lastEventId) {
-        console.error(`Client reconnecting with Last-Event-ID: ${lastEventId}`);
+        console.log(`Client reconnecting with Last-Event-ID: ${lastEventId}`);
     }
     else {
-        console.error(`Establishing new SSE stream for session ${sessionId}`);
+        console.log(`Establishing new SSE stream for session ${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'];
+// Handle DELETE requests for session termination
+app.delete("/mcp", async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
     if (!sessionId || !transports.has(sessionId)) {
         res.status(400).json({
-            jsonrpc: '2.0',
+            jsonrpc: "2.0",
             error: {
                 code: -32000,
-                message: 'Bad Request: No valid session ID provided',
+                message: "Bad Request: No valid session ID provided",
             },
             id: req?.body?.id,
         });
         return;
     }
-    console.error(`Received session termination request for session ${sessionId}`);
+    console.log(`Received session termination request for session ${sessionId}`);
     try {
         const transport = transports.get(sessionId);
         await transport.handleRequest(req, res);
     }
     catch (error) {
-        console.error('Error handling session termination:', error);
+        console.log("Error handling session termination:", error);
         if (!res.headersSent) {
             res.status(500).json({
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 error: {
                     code: -32603,
-                    message: 'Error handling session termination',
+                    message: "Error handling session termination",
                 },
                 id: req?.body?.id,
             });
@@ -152,23 +149,37 @@ app.delete('/mcp', async (req, res) => {
 });
 // Start the server
 const PORT = process.env.PORT || 3001;
-app.listen(PORT, () => {
+const server = app.listen(PORT, () => {
     console.error(`MCP Streamable HTTP Server listening on port ${PORT}`);
 });
+// Handle server errors
+server.on("error", (err) => {
+    const code = typeof err === "object" && err !== null && "code" in err
+        ? err.code
+        : undefined;
+    if (code === "EADDRINUSE") {
+        console.error(`Failed to start: Port ${PORT} is already in use. Set PORT to a free port or stop the conflicting process.`);
+    }
+    else {
+        console.error("HTTP server encountered an error while starting:", err);
+    }
+    // Ensure a non-zero exit so npm reports the failure instead of silently exiting
+    process.exit(1);
+});
 // Handle server shutdown
-process.on('SIGINT', async () => {
-    console.error('Shutting down server...');
+process.on("SIGINT", async () => {
+    console.log("Shutting down server...");
     // Close all active transports to properly clean up resources
     for (const sessionId in transports) {
         try {
-            console.error(`Closing transport for session ${sessionId}`);
+            console.log(`Closing transport for session ${sessionId}`);
             await transports.get(sessionId).close();
             transports.delete(sessionId);
         }
         catch (error) {
-            console.error(`Error closing transport for session ${sessionId}:`, error);
+            console.log(`Error closing transport for session ${sessionId}:`, error);
         }
     }
-    console.error('Server shutdown complete');
+    console.log("Server shutdown complete");
     process.exit(0);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelcontextprotocol/server-everything",
-  "version": "2025.12.18",
+  "version": "2026.1.14",
   "description": "MCP server that exercises all the features of the MCP protocol",
   "license": "MIT",
   "mcpName": "io.github.modelcontextprotocol/server-everything",
@@ -19,15 +19,17 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc && shx cp instructions.md dist/ && shx chmod +x dist/*.js",
+    "build": "tsc && shx cp -r docs dist/ && shx chmod +x dist/*.js",
     "prepare": "npm run build",
     "watch": "tsc --watch",
-    "start": "node dist/index.js",
-    "start:sse": "node dist/sse.js",
-    "start:streamableHttp": "node dist/streamableHttp.js"
+    "start:stdio": "node dist/index.js stdio",
+    "start:sse": "node dist/index.js sse",
+    "start:streamableHttp": "node dist/index.js streamableHttp",
+    "prettier:fix": "prettier --write .",
+    "prettier:check": "prettier --check ."
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.24.0",
+    "@modelcontextprotocol/sdk": "^1.25.2",
     "cors": "^2.8.5",
     "express": "^5.2.1",
     "jszip": "^3.10.1",
@@ -38,6 +40,7 @@
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.6",
     "shx": "^0.3.4",
-    "typescript": "^5.6.2"
+    "typescript": "^5.6.2",
+    "prettier": "^2.8.8"
   }
 }