@modelcontextprotocol/server-everything 2025.9.25 → 2025.12.18

package/README.md

@@ -196,7 +196,7 @@ Add the configuration to your user-level MCP configuration file. Open the Comman
 **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.
 
-> For more details about MCP configuration in VS Code, see the [official VS Code MCP documentation](https://code.visualstudio.com/docs/copilot/mcp).
+> For more details about MCP configuration in VS Code, see the [official VS Code MCP documentation](https://code.visualstudio.com/docs/copilot/customization/mcp-servers).
 
 #### NPX
 

package/dist/everything.js

@@ -1,15 +1,14 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { CallToolRequestSchema, CompleteRequestSchema, CreateMessageResultSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, RootsListChangedNotificationSchema, SubscribeRequestSchema, ToolSchema, UnsubscribeRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, CompleteRequestSchema, CreateMessageResultSchema, ElicitResultSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, RootsListChangedNotificationSchema, SubscribeRequestSchema, 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";
+import JSZip from "jszip";
 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"),
@@ -83,6 +82,9 @@ const StructuredContentSchema = {
             .describe("Humidity percentage"),
     })
 };
+const ZipResourcesInputSchema = z.object({
+    files: z.record(z.string().url().describe("URL of the file to include in the zip")).describe("Mapping of file names to URLs to include in the zip"),
+});
 var ToolName;
 (function (ToolName) {
     ToolName["ECHO"] = "echo";
@@ -96,6 +98,7 @@ var ToolName;
     ToolName["ELICITATION"] = "startElicitation";
     ToolName["GET_RESOURCE_LINKS"] = "getResourceLinks";
     ToolName["STRUCTURED_CONTENT"] = "structuredContent";
+    ToolName["ZIP_RESOURCES"] = "zip";
     ToolName["LIST_ROOTS"] = "listRoots";
 })(ToolName || (ToolName = {}));
 var PromptName;
@@ -167,7 +170,7 @@ export const createServer = () => {
         }
     };
     // Helper method to request sampling from client
-    const requestSampling = async (context, uri, maxTokens = 100) => {
+    const requestSampling = async (context, uri, maxTokens = 100, sendRequest) => {
         const request = {
             method: "sampling/createMessage",
             params: {
@@ -186,17 +189,7 @@ export const createServer = () => {
                 includeContext: "thisServer",
             },
         };
-        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());
+        return await sendRequest(request, CreateMessageResultSchema);
     };
     const ALL_RESOURCES = Array.from({ length: 100 }, (_, i) => {
         const uri = `test://static/resource/${i + 1}`;
@@ -263,11 +256,9 @@ export const createServer = () => {
         }
         throw new Error(`Unknown resource: ${uri}`);
     });
-    server.setRequestHandler(SubscribeRequestSchema, async (request) => {
+    server.setRequestHandler(SubscribeRequestSchema, async (request, extra) => {
         const { uri } = request.params;
         subscriptions.add(uri);
-        // Request sampling from client when someone subscribes
-        await requestSampling("A new subscription was started", uri);
         return {};
     });
     server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
@@ -435,6 +426,11 @@ export const createServer = () => {
                 inputSchema: zodToJsonSchema(StructuredContentSchema.input),
                 outputSchema: zodToJsonSchema(StructuredContentSchema.output),
             },
+            {
+                name: ToolName.ZIP_RESOURCES,
+                description: "Compresses the provided resource files (mapping of name to URI, which can be a data URI) to a zip file, which it returns as a data URI resource link.",
+                inputSchema: zodToJsonSchema(ZipResourcesInputSchema),
+            }
         ];
         if (clientCapabilities.roots)
             tools.push({
@@ -445,7 +441,7 @@ export const createServer = () => {
         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.",
+                description: "Elicitation test tool that demonstrates how to request user input with various field types (string, boolean, email, uri, date, integer, number, enum)",
                 inputSchema: zodToJsonSchema(ElicitationSchema),
             });
         return { tools };
@@ -510,10 +506,10 @@ export const createServer = () => {
         if (name === ToolName.SAMPLE_LLM) {
             const validatedArgs = SampleLLMSchema.parse(args);
             const { prompt, maxTokens } = validatedArgs;
-            const result = await requestSampling(prompt, ToolName.SAMPLE_LLM, maxTokens);
+            const result = await requestSampling(prompt, ToolName.SAMPLE_LLM, maxTokens, extra.sendRequest);
             return {
                 content: [
-                    { type: "text", text: `LLM sampling result: ${result.content.text}` },
+                    { type: "text", text: `LLM sampling result: ${Array.isArray(result.content) ? result.content.map(c => c.type === "text" ? c.text : JSON.stringify(c)).join("") : (result.content.type === "text" ? result.content.text : JSON.stringify(result.content))}` },
                 ],
             };
         }
@@ -612,36 +608,155 @@ export const createServer = () => {
         }
         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'
+            const elicitationResult = await extra.sendRequest({
+                method: 'elicitation/create',
+                params: {
+                    message: 'Please provide inputs for the following fields:',
+                    requestedSchema: {
+                        type: 'object',
+                        properties: {
+                            name: {
+                                title: 'String',
+                                type: 'string',
+                                description: 'Your full, legal name',
+                            },
+                            check: {
+                                title: 'Boolean',
+                                type: 'boolean',
+                                description: 'Agree to the terms and conditions',
+                            },
+                            firstLine: {
+                                title: 'String with default',
+                                type: 'string',
+                                description: 'Favorite first line of a story',
+                                default: 'It was a dark and stormy night.',
+                            },
+                            email: {
+                                title: 'String with email format',
+                                type: 'string',
+                                format: 'email',
+                                description: 'Your email address (will be verified, and never shared with anyone else)',
+                            },
+                            homepage: {
+                                type: 'string',
+                                format: 'uri',
+                                title: 'String with uri format',
+                                description: 'Portfolio / personal website',
+                            },
+                            birthdate: {
+                                title: 'String with date format',
+                                type: 'string',
+                                format: 'date',
+                                description: 'Your date of birth',
+                            },
+                            integer: {
+                                title: 'Integer',
+                                type: 'integer',
+                                description: 'Your favorite integer (do not give us your phone number, pin, or other sensitive info)',
+                                minimum: 1,
+                                maximum: 100,
+                                default: 42,
+                            },
+                            number: {
+                                title: 'Number in range 1-1000',
+                                type: 'number',
+                                description: 'Favorite number (there are no wrong answers)',
+                                minimum: 0,
+                                maximum: 1000,
+                                default: 3.14,
+                            },
+                            untitledSingleSelectEnum: {
+                                type: 'string',
+                                title: 'Untitled Single Select Enum',
+                                description: 'Choose your favorite friend',
+                                enum: ['Monica', 'Rachel', 'Joey', 'Chandler', 'Ross', 'Phoebe'],
+                                default: 'Monica'
+                            },
+                            untitledMultipleSelectEnum: {
+                                type: 'array',
+                                title: 'Untitled Multiple Select Enum',
+                                description: 'Choose your favorite instruments',
+                                minItems: 1,
+                                maxItems: 3,
+                                items: { type: 'string', enum: ['Guitar', 'Piano', 'Violin', 'Drums', 'Bass'] },
+                                default: ['Guitar']
+                            },
+                            titledSingleSelectEnum: {
+                                type: 'string',
+                                title: 'Titled Single Select Enum',
+                                description: 'Choose your favorite hero',
+                                oneOf: [
+                                    { const: 'hero-1', title: 'Superman' },
+                                    { const: 'hero-2', title: 'Green Lantern' },
+                                    { const: 'hero-3', title: 'Wonder Woman' }
+                                ],
+                                default: 'hero-1'
+                            },
+                            titledMultipleSelectEnum: {
+                                type: 'array',
+                                title: 'Titled Multiple Select Enum',
+                                description: 'Choose your favorite types of fish',
+                                minItems: 1,
+                                maxItems: 3,
+                                items: {
+                                    anyOf: [
+                                        { const: 'fish-1', title: 'Tuna' },
+                                        { const: 'fish-2', title: 'Salmon' },
+                                        { const: 'fish-3', title: 'Trout' }
+                                    ]
+                                },
+                                default: ['fish-1']
+                            },
+                            legacyTitledEnum: {
+                                type: 'string',
+                                title: 'Legacy Titled Single Select Enum',
+                                description: 'Choose your favorite type of pet',
+                                enum: ['pet-1', 'pet-2', 'pet-3', 'pet-4', 'pet-5'],
+                                enumNames: ['Cats', 'Dogs', 'Birds', 'Fish', 'Reptiles'],
+                                default: 'pet-1',
+                            }
+                        },
+                        required: ['name'],
                     },
-                }
-            });
+                },
+            }, ElicitResultSchema, { timeout: 10 * 60 * 1000 /* 10 minutes */ });
             // Handle different response actions
             const content = [];
             if (elicitationResult.action === 'accept' && elicitationResult.content) {
                 content.push({
                     type: "text",
-                    text: `✅ User provided their favorite things!`,
+                    text: `✅ User provided the requested information!`,
                 });
                 // Only access elicitationResult.content when action is accept
-                const { color, number, pets } = elicitationResult.content;
+                const userData = elicitationResult.content;
+                const lines = [];
+                if (userData.name)
+                    lines.push(`- Name: ${userData.name}`);
+                if (userData.check !== undefined)
+                    lines.push(`- Agreed to terms: ${userData.check}`);
+                if (userData.color)
+                    lines.push(`- Favorite Color: ${userData.color}`);
+                if (userData.email)
+                    lines.push(`- Email: ${userData.email}`);
+                if (userData.homepage)
+                    lines.push(`- Homepage: ${userData.homepage}`);
+                if (userData.birthdate)
+                    lines.push(`- Birthdate: ${userData.birthdate}`);
+                if (userData.integer !== undefined)
+                    lines.push(`- Favorite Integer: ${userData.integer}`);
+                if (userData.number !== undefined)
+                    lines.push(`- Favorite Number: ${userData.number}`);
+                if (userData.petType)
+                    lines.push(`- Pet Type: ${userData.petType}`);
                 content.push({
                     type: "text",
-                    text: `Their favorites are:\n- Color: ${color || 'not specified'}\n- Number: ${number || 'not specified'}\n- Pets: ${pets || 'not specified'}`,
+                    text: `User inputs:\n${lines.join('\n')}`,
                 });
             }
             else if (elicitationResult.action === 'decline') {
                 content.push({
                     type: "text",
-                    text: `❌ User declined to provide their favorite things.`,
+                    text: `❌ User declined to provide the requested information.`,
                 });
             }
             else if (elicitationResult.action === 'cancel') {
@@ -698,6 +813,33 @@ export const createServer = () => {
                 structuredContent: weather
             };
         }
+        if (name === ToolName.ZIP_RESOURCES) {
+            const { files } = ZipResourcesInputSchema.parse(args);
+            const zip = new JSZip();
+            for (const [fileName, fileUrl] of Object.entries(files)) {
+                try {
+                    const response = await fetch(fileUrl);
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch ${fileUrl}: ${response.statusText}`);
+                    }
+                    const arrayBuffer = await response.arrayBuffer();
+                    zip.file(fileName, arrayBuffer);
+                }
+                catch (error) {
+                    throw new Error(`Error fetching file ${fileUrl}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            const uri = `data:application/zip;base64,${await zip.generateAsync({ type: "base64" })}`;
+            return {
+                content: [
+                    {
+                        type: "resource_link",
+                        mimeType: "application/zip",
+                        uri,
+                    },
+                ],
+            };
+        }
         if (name === ToolName.LIST_ROOTS) {
             ListRootsSchema.parse(args);
             if (!clientSupportsRoots) {

package/dist/stdio.js

@@ -5,13 +5,16 @@ console.error('Starting default (STDIO) server...');
 async function main() {
     const transport = new StdioServerTransport();
     const { server, cleanup, startNotificationIntervals } = createServer();
+    // Cleanup when client disconnects
+    server.onclose = async () => {
+        await cleanup();
+        process.exit(0);
+    };
     await server.connect(transport);
     startNotificationIntervals();
     // Cleanup on exit
     process.on("SIGINT", async () => {
-        await cleanup();
         await server.close();
-        process.exit(0);
     });
 }
 main().catch((error) => {

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@modelcontextprotocol/server-everything",
-  "version": "2025.9.25",
+  "version": "2025.12.18",
   "description": "MCP server that exercises all the features of the MCP protocol",
   "license": "MIT",
+  "mcpName": "io.github.modelcontextprotocol/server-everything",
   "author": "Anthropic, PBC (https://anthropic.com)",
   "homepage": "https://modelcontextprotocol.io",
   "bugs": "https://github.com/modelcontextprotocol/servers/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/modelcontextprotocol/servers.git"
+  },
   "type": "module",
   "bin": {
     "mcp-server-everything": "dist/index.js"
@@ -22,15 +27,16 @@
     "start:streamableHttp": "node dist/streamableHttp.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.18.0",
+    "@modelcontextprotocol/sdk": "^1.24.0",
     "cors": "^2.8.5",
-    "express": "^4.21.1",
-    "zod": "^3.23.8",
+    "express": "^5.2.1",
+    "jszip": "^3.10.1",
+    "zod": "^3.25.0",
     "zod-to-json-schema": "^3.23.5"
   },
   "devDependencies": {
     "@types/cors": "^2.8.19",
-    "@types/express": "^5.0.0",
+    "@types/express": "^5.0.6",
     "shx": "^0.3.4",
     "typescript": "^5.6.2"
   }