@modelcontextprotocol/server-everything 2025.5.12 → 2025.7.29

package/README.md

@@ -27,24 +27,24 @@ This MCP server attempts to exercise all the features of the MCP protocol. It is
    - Returns: Completion message with duration and steps
    - Sends progress notifications during execution
 
-4. `sampleLLM`
+4. `printEnv`
+   - Prints all environment variables
+   - Useful for debugging MCP server configuration
+   - No inputs required
+   - Returns: JSON string of all environment variables
+
+5. `sampleLLM`
    - Demonstrates LLM sampling capability using MCP sampling feature
    - Inputs:
      - `prompt` (string): The prompt to send to the LLM
      - `maxTokens` (number, default: 100): Maximum tokens to generate
    - Returns: Generated LLM response
 
-5. `getTinyImage`
+6. `getTinyImage`
    - Returns a small test image
    - No inputs required
    - Returns: Base64 encoded PNG image data
 
-6. `printEnv`
-   - Prints all environment variables
-   - Useful for debugging MCP server configuration
-   - No inputs required
-   - Returns: JSON string of all environment variables
-
 7. `annotatedMessage`
    - Demonstrates how annotations can be used to provide metadata about content
    - Inputs:
@@ -72,6 +72,23 @@ This MCP server attempts to exercise all the features of the MCP protocol. It is
      - Embedded resource with `type: "resource"`
      - Text instruction for using the resource URI
 
+9. `startElicitation`
+   - Initiates an elicitation (interaction) within the MCP client.
+   - Inputs:
+      - `color` (string): Favorite color
+      - `number` (number, 1-100): Favorite number
+      - `pets` (enum): Favorite pet
+   - Returns: Confirmation of the elicitation demo with selection summary.
+
+10. `structuredContent`
+   - Demonstrates a tool returning structured content using the example in the specification
+   - Provides an output schema to allow testing of client SHOULD advisory to validate the result using the schema
+   - Inputs:
+     - `location` (string): A location or ZIP code, mock data is returned regardless of value
+   - Returns: a response with
+     - `structuredContent` field conformant to the output schema
+     - A backward compatible Text Content field, a SHOULD advisory in the specification
+
 ### Resources
 
 The server provides 100 test resources in two formats:

package/dist/everything.js

@@ -2,7 +2,14 @@ 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;
+const ToolOutputSchema = ToolSchema.shape.outputSchema;
 /* Input schemas for tools implemented in this server */
 const EchoSchema = z.object({
     message: z.string().describe("Message to echo"),
@@ -16,7 +23,10 @@ const LongRunningOperationSchema = z.object({
         .number()
         .default(10)
         .describe("Duration of the operation in seconds"),
-    steps: z.number().default(5).describe("Number of steps in the operation"),
+    steps: z
+        .number()
+        .default(5)
+        .describe("Number of steps in the operation"),
 });
 const PrintEnvSchema = z.object({});
 const SampleLLMSchema = z.object({
@@ -26,12 +36,6 @@ const SampleLLMSchema = z.object({
         .default(100)
         .describe("Maximum number of tokens to generate"),
 });
-// Example completion values
-const EXAMPLE_COMPLETIONS = {
-    style: ["casual", "formal", "technical", "friendly"],
-    temperature: ["0", "0.5", "0.7", "1.0"],
-    resourceId: ["1", "2", "3", "4", "5"],
-};
 const GetTinyImageSchema = z.object({});
 const AnnotatedMessageSchema = z.object({
     messageType: z
@@ -49,6 +53,35 @@ const GetResourceReferenceSchema = z.object({
         .max(100)
         .describe("ID of the resource to reference (1-100)"),
 });
+const ElicitationSchema = z.object({});
+const GetResourceLinksSchema = z.object({
+    count: z
+        .number()
+        .min(1)
+        .max(10)
+        .default(3)
+        .describe("Number of resource links to return (1-10)"),
+});
+const StructuredContentSchema = {
+    input: z.object({
+        location: z
+            .string()
+            .trim()
+            .min(1)
+            .describe("City name or zip code"),
+    }),
+    output: z.object({
+        temperature: z
+            .number()
+            .describe("Temperature in celsius"),
+        conditions: z
+            .string()
+            .describe("Weather conditions description"),
+        humidity: z
+            .number()
+            .describe("Humidity percentage"),
+    })
+};
 var ToolName;
 (function (ToolName) {
     ToolName["ECHO"] = "echo";
@@ -59,6 +92,9 @@ var ToolName;
     ToolName["GET_TINY_IMAGE"] = "getTinyImage";
     ToolName["ANNOTATED_MESSAGE"] = "annotatedMessage";
     ToolName["GET_RESOURCE_REFERENCE"] = "getResourceReference";
+    ToolName["ELICITATION"] = "startElicitation";
+    ToolName["GET_RESOURCE_LINKS"] = "getResourceLinks";
+    ToolName["STRUCTURED_CONTENT"] = "structuredContent";
 })(ToolName || (ToolName = {}));
 var PromptName;
 (function (PromptName) {
@@ -66,9 +102,16 @@ var PromptName;
     PromptName["COMPLEX"] = "complex_prompt";
     PromptName["RESOURCE"] = "resource_prompt";
 })(PromptName || (PromptName = {}));
+// Example completion values
+const EXAMPLE_COMPLETIONS = {
+    style: ["casual", "formal", "technical", "friendly"],
+    temperature: ["0", "0.5", "0.7", "1.0"],
+    resourceId: ["1", "2", "3", "4", "5"],
+};
 export const createServer = () => {
     const server = new Server({
         name: "example-servers/everything",
+        title: "Everything Example Server",
         version: "1.0.0",
     }, {
         capabilities: {
@@ -77,7 +120,9 @@ export const createServer = () => {
             tools: {},
             logging: {},
             completions: {},
+            elicitation: {},
         },
+        instructions
     });
     let subscriptions = new Set();
     let subsUpdateInterval;
@@ -120,9 +165,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",
@@ -151,6 +196,16 @@ export const createServer = () => {
         };
         return await server.request(request, CreateMessageResultSchema);
     };
+    const requestElicitation = async (message, requestedSchema) => {
+        const request = {
+            method: 'elicitation/create',
+            params: {
+                message,
+                requestedSchema
+            }
+        };
+        return await server.request(request, z.any());
+    };
     const ALL_RESOURCES = Array.from({ length: 100 }, (_, i) => {
         const uri = `test://static/resource/${i + 1}`;
         if (i % 2 === 0) {
@@ -347,16 +402,16 @@ export const createServer = () => {
                 description: "Adds two numbers",
                 inputSchema: zodToJsonSchema(AddSchema),
             },
-            {
-                name: ToolName.PRINT_ENV,
-                description: "Prints all environment variables, helpful for debugging MCP server configuration",
-                inputSchema: zodToJsonSchema(PrintEnvSchema),
-            },
             {
                 name: ToolName.LONG_RUNNING_OPERATION,
                 description: "Demonstrates a long running operation with progress updates",
                 inputSchema: zodToJsonSchema(LongRunningOperationSchema),
             },
+            {
+                name: ToolName.PRINT_ENV,
+                description: "Prints all environment variables, helpful for debugging MCP server configuration",
+                inputSchema: zodToJsonSchema(PrintEnvSchema),
+            },
             {
                 name: ToolName.SAMPLE_LLM,
                 description: "Samples from an LLM using MCP's sampling feature",
@@ -377,6 +432,22 @@ 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",
+                inputSchema: zodToJsonSchema(GetResourceLinksSchema),
+            },
+            {
+                name: ToolName.STRUCTURED_CONTENT,
+                description: "Returns structured content along with an output schema for client data validation",
+                inputSchema: zodToJsonSchema(StructuredContentSchema.input),
+                outputSchema: zodToJsonSchema(StructuredContentSchema.output),
+            },
         ];
         return { tools };
     });
@@ -467,31 +538,6 @@ export const createServer = () => {
                 ],
             };
         }
-        if (name === ToolName.GET_RESOURCE_REFERENCE) {
-            const validatedArgs = GetResourceReferenceSchema.parse(args);
-            const resourceId = validatedArgs.resourceId;
-            const resourceIndex = resourceId - 1;
-            if (resourceIndex < 0 || resourceIndex >= ALL_RESOURCES.length) {
-                throw new Error(`Resource with ID ${resourceId} does not exist`);
-            }
-            const resource = ALL_RESOURCES[resourceIndex];
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Returning resource reference for Resource ${resourceId}:`,
-                    },
-                    {
-                        type: "resource",
-                        resource: resource,
-                    },
-                    {
-                        type: "text",
-                        text: `You can access this resource using the URI: ${resource.uri}`,
-                    },
-                ],
-            };
-        }
         if (name === ToolName.ANNOTATED_MESSAGE) {
             const { messageType, includeImage } = AnnotatedMessageSchema.parse(args);
             const content = [];
@@ -540,6 +586,119 @@ export const createServer = () => {
             }
             return { content };
         }
+        if (name === ToolName.GET_RESOURCE_REFERENCE) {
+            const validatedArgs = GetResourceReferenceSchema.parse(args);
+            const resourceId = validatedArgs.resourceId;
+            const resourceIndex = resourceId - 1;
+            if (resourceIndex < 0 || resourceIndex >= ALL_RESOURCES.length) {
+                throw new Error(`Resource with ID ${resourceId} does not exist`);
+            }
+            const resource = ALL_RESOURCES[resourceIndex];
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Returning resource reference for Resource ${resourceId}:`,
+                    },
+                    {
+                        type: "resource",
+                        resource: resource,
+                    },
+                    {
+                        type: "text",
+                        text: `You can access this resource using the URI: ${resource.uri}`,
+                    },
+                ],
+            };
+        }
+        if (name === ToolName.ELICITATION) {
+            ElicitationSchema.parse(args);
+            const elicitationResult = await requestElicitation('What are your favorite things?', {
+                type: 'object',
+                properties: {
+                    color: { type: 'string', description: 'Favorite color' },
+                    number: { type: 'integer', description: 'Favorite number', minimum: 1, maximum: 100 },
+                    pets: {
+                        type: 'string',
+                        enum: ['cats', 'dogs', 'birds', 'fish', 'reptiles'],
+                        description: 'Favorite pets'
+                    },
+                }
+            });
+            // Handle different response actions
+            const content = [];
+            if (elicitationResult.action === 'accept' && elicitationResult.content) {
+                content.push({
+                    type: "text",
+                    text: `✅ User provided their favorite things!`,
+                });
+                // Only access elicitationResult.content when action is accept
+                const { color, number, pets } = elicitationResult.content;
+                content.push({
+                    type: "text",
+                    text: `Their favorites are:\n- Color: ${color || 'not specified'}\n- Number: ${number || 'not specified'}\n- Pets: ${pets || 'not specified'}`,
+                });
+            }
+            else if (elicitationResult.action === 'decline') {
+                content.push({
+                    type: "text",
+                    text: `❌ User declined to provide their favorite things.`,
+                });
+            }
+            else if (elicitationResult.action === 'cancel') {
+                content.push({
+                    type: "text",
+                    text: `⚠️ User cancelled the elicitation dialog.`,
+                });
+            }
+            // Include raw result for debugging
+            content.push({
+                type: "text",
+                text: `\nRaw result: ${JSON.stringify(elicitationResult, null, 2)}`,
+            });
+            return { content };
+        }
+        if (name === ToolName.GET_RESOURCE_LINKS) {
+            const { count } = GetResourceLinksSchema.parse(args);
+            const content = [];
+            // Add intro text
+            content.push({
+                type: "text",
+                text: `Here are ${count} resource links to resources available in this server (see full output in tool response if your client does not support resource_link yet):`,
+            });
+            // Return resource links to actual resources from ALL_RESOURCES
+            const actualCount = Math.min(count, ALL_RESOURCES.length);
+            for (let i = 0; i < actualCount; i++) {
+                const resource = ALL_RESOURCES[i];
+                content.push({
+                    type: "resource_link",
+                    uri: resource.uri,
+                    name: resource.name,
+                    description: `Resource ${i + 1}: ${resource.mimeType === "text/plain"
+                        ? "plaintext resource"
+                        : "binary blob resource"}`,
+                    mimeType: resource.mimeType,
+                });
+            }
+            return { content };
+        }
+        if (name === ToolName.STRUCTURED_CONTENT) {
+            // The same response is returned for every input.
+            const validatedArgs = StructuredContentSchema.input.parse(args);
+            const weather = {
+                temperature: 22.5,
+                conditions: "Partly cloudy",
+                humidity: 65
+            };
+            const backwardCompatiblecontent = {
+                type: "text",
+                text: JSON.stringify(weather)
+            };
+            return {
+                content: [backwardCompatiblecontent],
+                structuredContent: weather
+            };
+        }
         throw new Error(`Unknown tool: ${name}`);
     });
     server.setRequestHandler(CompleteRequestSchema, async (request) => {

package/dist/instructions.md

@@ -0,0 +1,23 @@
+Testing and demonstration server for MCP protocol features.
+
+## Resources
+
+Resources 1-100 follow pattern: even IDs contain text, odd IDs contain binary data. Resources are 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 is 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

@@ -3,23 +3,42 @@ 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/streamableHttp.js

@@ -5,19 +5,19 @@ 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({
@@ -26,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
@@ -77,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: {
@@ -93,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: {
@@ -115,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) {
@@ -138,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.5.12",
+  "version": "2025.7.29",
   "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.11.0",
+    "@modelcontextprotocol/sdk": "^1.12.0",
     "express": "^4.21.1",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.5"