@modelcontextprotocol/server-everything 2025.12.18 → 2026.1.26

package/dist/tools/trigger-elicitation-request.js

@@ -0,0 +1,210 @@
+import { ElicitResultSchema, } from "@modelcontextprotocol/sdk/types.js";
+// Tool configuration
+const name = "trigger-elicitation-request";
+const config = {
+    title: "Trigger Elicitation Request Tool",
+    description: "Trigger a Request from the Server for User Elicitation",
+    inputSchema: {},
+};
+/**
+ * Registers the 'trigger-elicitation-request' tool.
+ *
+ * If the client does not support the elicitation capability, the tool is not registered.
+ *
+ * The registered tool sends an elicitation request for the user to provide information
+ * based on a pre-defined schema of fields including text inputs, booleans, numbers,
+ * email, dates, enums of various types, etc. It uses validation and handles multiple
+ * possible outcomes from the user's response, such as acceptance with content, decline,
+ * or cancellation of the dialog. The process also ensures parsing and validating
+ * the elicitation input arguments at runtime.
+ *
+ * The elicitation dialog response is returned, formatted into a structured result,
+ * which contains both user-submitted input data (if provided) and debugging information,
+ * including raw results.
+ *
+ * @param {McpServer} server - TThe McpServer instance where the tool will be registered.
+ */
+export const registerTriggerElicitationRequestTool = (server) => {
+    // Does the client support elicitation?
+    const clientCapabilities = server.server.getClientCapabilities() || {};
+    const clientSupportsElicitation = clientCapabilities.elicitation !== undefined;
+    // If so, register tool
+    if (clientSupportsElicitation) {
+        server.registerTool(name, config, async (args, extra) => {
+            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 the requested information!`,
+                });
+                // Only access elicitationResult.content when action is accept
+                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: `User inputs:\n${lines.join("\n")}`,
+                });
+            }
+            else if (elicitationResult.action === "decline") {
+                content.push({
+                    type: "text",
+                    text: `❌ User declined to provide the requested information.`,
+                });
+            }
+            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 };
+        });
+    }
+};

package/dist/tools/trigger-long-running-operation.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+// Tool input schema
+const TriggerLongRunningOperationSchema = z.object({
+    duration: z
+        .number()
+        .default(10)
+        .describe("Duration of the operation in seconds"),
+    steps: z.number().default(5).describe("Number of steps in the operation"),
+});
+// Tool configuration
+const name = "trigger-long-running-operation";
+const config = {
+    title: "Trigger Long Running Operation Tool",
+    description: "Demonstrates a long running operation with progress updates.",
+    inputSchema: TriggerLongRunningOperationSchema,
+};
+/**
+ * Registers the 'trigger-tong-running-operation' tool.
+ *
+ * The registered tool starts a long-running operation defined by a specific duration and
+ * number of steps.
+ *
+ * Progress notifications are sent back to the client at each step if a `progressToken`
+ * is provided in the metadata.
+ *
+ * At the end of the operation, the tool returns a message indicating the completion of the
+ * operation, including the total duration and steps.
+ *
+ * @param {McpServer} server - The McpServer instance where the tool will be registered.
+ */
+export const registerTriggerLongRunningOperationTool = (server) => {
+    server.registerTool(name, config, async (args, extra) => {
+        const validatedArgs = TriggerLongRunningOperationSchema.parse(args);
+        const { duration, steps } = validatedArgs;
+        const stepDuration = duration / steps;
+        const progressToken = extra._meta?.progressToken;
+        for (let i = 1; i < steps + 1; i++) {
+            await new Promise((resolve) => setTimeout(resolve, stepDuration * 1000));
+            if (progressToken !== undefined) {
+                await server.server.notification({
+                    method: "notifications/progress",
+                    params: {
+                        progress: i,
+                        total: steps,
+                        progressToken,
+                    },
+                }, { relatedRequestId: extra.requestId });
+            }
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Long running operation completed. Duration: ${duration} seconds, Steps: ${steps}.`,
+                },
+            ],
+        };
+    });
+};

package/dist/tools/trigger-sampling-request-async.js

@@ -0,0 +1,168 @@
+import { z } from "zod";
+// Tool input schema
+const TriggerSamplingRequestAsyncSchema = z.object({
+    prompt: z.string().describe("The prompt to send to the LLM"),
+    maxTokens: z
+        .number()
+        .default(100)
+        .describe("Maximum number of tokens to generate"),
+});
+// Tool configuration
+const name = "trigger-sampling-request-async";
+const config = {
+    title: "Trigger Async Sampling Request Tool",
+    description: "Trigger an async sampling request that the CLIENT executes as a background task. " +
+        "Demonstrates bidirectional MCP tasks where the server sends a request and the client " +
+        "executes it asynchronously, allowing the server to poll for progress and results.",
+    inputSchema: TriggerSamplingRequestAsyncSchema,
+};
+// Poll interval in milliseconds
+const POLL_INTERVAL = 1000;
+// Maximum poll attempts before timeout
+const MAX_POLL_ATTEMPTS = 60;
+/**
+ * Registers the 'trigger-sampling-request-async' tool.
+ *
+ * This tool demonstrates bidirectional MCP tasks:
+ * - Server sends sampling request to client with task metadata
+ * - Client creates a task and returns CreateTaskResult
+ * - Server polls client's tasks/get endpoint for status
+ * - Server fetches final result from client's tasks/result endpoint
+ *
+ * @param {McpServer} server - The McpServer instance where the tool will be registered.
+ */
+export const registerTriggerSamplingRequestAsyncTool = (server) => {
+    // Check client capabilities
+    const clientCapabilities = server.server.getClientCapabilities() || {};
+    // Client must support sampling AND tasks.requests.sampling
+    const clientSupportsSampling = clientCapabilities.sampling !== undefined;
+    const clientTasksCapability = clientCapabilities.tasks;
+    const clientSupportsAsyncSampling = clientTasksCapability?.requests?.sampling?.createMessage !== undefined;
+    if (clientSupportsSampling && clientSupportsAsyncSampling) {
+        server.registerTool(name, config, async (args, extra) => {
+            const validatedArgs = TriggerSamplingRequestAsyncSchema.parse(args);
+            const { prompt, maxTokens } = validatedArgs;
+            // Create the sampling request WITH task metadata
+            // The params.task field signals to the client that this should be executed as a task
+            const request = {
+                method: "sampling/createMessage",
+                params: {
+                    task: {
+                        ttl: 300000, // 5 minutes
+                    },
+                    messages: [
+                        {
+                            role: "user",
+                            content: {
+                                type: "text",
+                                text: `Resource ${name} context: ${prompt}`,
+                            },
+                        },
+                    ],
+                    systemPrompt: "You are a helpful test server.",
+                    maxTokens,
+                    temperature: 0.7,
+                },
+            };
+            // Send the sampling request
+            // Client may return either:
+            // - CreateMessageResult (synchronous execution)
+            // - CreateTaskResult (task-based execution with { task } object)
+            const samplingResponse = await extra.sendRequest(request, z.union([
+                // CreateTaskResult - client created a task
+                z.object({
+                    task: z.object({
+                        taskId: z.string(),
+                        status: z.string(),
+                        pollInterval: z.number().optional(),
+                        statusMessage: z.string().optional(),
+                    }),
+                }),
+                // CreateMessageResult - synchronous execution
+                z.object({
+                    role: z.string(),
+                    content: z.any(),
+                    model: z.string(),
+                    stopReason: z.string().optional(),
+                }),
+            ]));
+            // Check if client returned CreateTaskResult (has task object)
+            const isTaskResult = "task" in samplingResponse && samplingResponse.task;
+            if (!isTaskResult) {
+                // Client executed synchronously - return the direct response
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `[SYNC] Client executed synchronously:\n${JSON.stringify(samplingResponse, null, 2)}`,
+                        },
+                    ],
+                };
+            }
+            const taskId = samplingResponse.task.taskId;
+            const statusMessages = [];
+            statusMessages.push(`Task created: ${taskId}`);
+            // Poll for task completion
+            let attempts = 0;
+            let taskStatus = samplingResponse.task.status;
+            let taskStatusMessage;
+            while (taskStatus !== "completed" &&
+                taskStatus !== "failed" &&
+                taskStatus !== "cancelled" &&
+                attempts < MAX_POLL_ATTEMPTS) {
+                // Wait before polling
+                await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+                attempts++;
+                // Get task status from client
+                const pollResult = await extra.sendRequest({
+                    method: "tasks/get",
+                    params: { taskId },
+                }, z
+                    .object({
+                    status: z.string(),
+                    statusMessage: z.string().optional(),
+                })
+                    .passthrough());
+                taskStatus = pollResult.status;
+                taskStatusMessage = pollResult.statusMessage;
+                statusMessages.push(`Poll ${attempts}: ${taskStatus}${taskStatusMessage ? ` - ${taskStatusMessage}` : ""}`);
+            }
+            // Check for timeout
+            if (attempts >= MAX_POLL_ATTEMPTS) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `[TIMEOUT] Task timed out after ${MAX_POLL_ATTEMPTS} poll attempts\n\nProgress:\n${statusMessages.join("\n")}`,
+                        },
+                    ],
+                };
+            }
+            // Check for failure/cancellation
+            if (taskStatus === "failed" || taskStatus === "cancelled") {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `[${taskStatus.toUpperCase()}] ${taskStatusMessage || "No message"}\n\nProgress:\n${statusMessages.join("\n")}`,
+                        },
+                    ],
+                };
+            }
+            // Fetch the final result
+            const result = await extra.sendRequest({
+                method: "tasks/result",
+                params: { taskId },
+            }, z.any());
+            // Return the result with status history
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `[COMPLETED] Async sampling completed!\n\n**Progress:**\n${statusMessages.join("\n")}\n\n**Result:**\n${JSON.stringify(result, null, 2)}`,
+                    },
+                ],
+            };
+        });
+    }
+};

package/dist/tools/trigger-sampling-request.js

@@ -0,0 +1,71 @@
+import { CreateMessageResultSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+// Tool input schema
+const TriggerSamplingRequestSchema = z.object({
+    prompt: z.string().describe("The prompt to send to the LLM"),
+    maxTokens: z
+        .number()
+        .default(100)
+        .describe("Maximum number of tokens to generate"),
+});
+// Tool configuration
+const name = "trigger-sampling-request";
+const config = {
+    title: "Trigger Sampling Request Tool",
+    description: "Trigger a Request from the Server for LLM Sampling",
+    inputSchema: TriggerSamplingRequestSchema,
+};
+/**
+ * Registers the 'trigger-sampling-request' tool.
+ *
+ * If the client does not support the sampling capability, the tool is not registered.
+ *
+ * The registered tool performs the following operations:
+ * - Validates incoming arguments using `TriggerSamplingRequestSchema`.
+ * - Constructs a `sampling/createMessage` request object using provided prompt and maximum tokens.
+ * - Sends the request to the server for sampling.
+ * - Formats and returns the sampling result content to the client.
+ *
+ * @param {McpServer} server - The McpServer instance where the tool will be registered.
+ */
+export const registerTriggerSamplingRequestTool = (server) => {
+    // Does the client support sampling?
+    const clientCapabilities = server.server.getClientCapabilities() || {};
+    const clientSupportsSampling = clientCapabilities.sampling !== undefined;
+    // If so, register tool
+    if (clientSupportsSampling) {
+        server.registerTool(name, config, async (args, extra) => {
+            const validatedArgs = TriggerSamplingRequestSchema.parse(args);
+            const { prompt, maxTokens } = validatedArgs;
+            // Create the sampling request
+            const request = {
+                method: "sampling/createMessage",
+                params: {
+                    messages: [
+                        {
+                            role: "user",
+                            content: {
+                                type: "text",
+                                text: `Resource ${name} context: ${prompt}`,
+                            },
+                        },
+                    ],
+                    systemPrompt: "You are a helpful test server.",
+                    maxTokens,
+                    temperature: 0.7,
+                },
+            };
+            // Send the sampling request to the client
+            const result = await extra.sendRequest(request, CreateMessageResultSchema);
+            // Return the result to the client
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `LLM sampling result: \n${JSON.stringify(result, null, 2)}`,
+                    },
+                ],
+            };
+        });
+    }
+};

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

@@ -1,43 +1,50 @@
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import express from "express";
-import { createServer } from "./everything.js";
-import cors from 'cors';
-console.error('Starting SSE server...');
+import { createServer } from "../server/index.js";
+import cors from "cors";
+console.error("Starting SSE 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",
-    "preflightContinue": false,
-    "optionsSuccessStatus": 204,
-})); // Enable CORS for all routes so Inspector can connect
+    origin: "*", // use "*" with caution in production
+    methods: "GET,POST",
+    preflightContinue: false,
+    optionsSuccessStatus: 204,
+}));
+// Map sessionId to transport for each client
 const transports = new Map();
+// Handle GET requests for new SSE streams
 app.get("/sse", async (req, res) => {
     let transport;
-    const { server, cleanup, startNotificationIntervals } = createServer();
+    const { server, cleanup } = createServer();
+    // Session Id should not exist for GET /sse requests
     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
+        // Create and store transport for the 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);
-        // Start notification intervals after client connects
-        startNotificationIntervals(transport.sessionId);
+        const sessionId = transport.sessionId;
+        console.error("Client Connected: ", sessionId);
         // Handle close of connection
-        server.onclose = async () => {
-            console.error("Client Disconnected: ", transport.sessionId);
-            transports.delete(transport.sessionId);
-            await cleanup();
+        server.server.onclose = async () => {
+            const sessionId = transport.sessionId;
+            console.error("Client Disconnected: ", sessionId);
+            transports.delete(sessionId);
+            cleanup(sessionId);
         };
     }
 });
+// Handle POST requests for client messages
 app.post("/message", async (req, res) => {
+    // Session Id should exist for POST /message requests
     const sessionId = req?.query?.sessionId;
+    // Get the transport for this session and use it to handle the request
     const transport = transports.get(sessionId);
     if (transport) {
         console.error("Client Message from", sessionId);
@@ -47,6 +54,7 @@ app.post("/message", async (req, res) => {
         console.error(`No transport found for sessionId ${sessionId}`);
     }
 });
+// Start the express server
 const PORT = process.env.PORT || 3001;
 app.listen(PORT, () => {
     console.error(`Server is running on port ${PORT}`);

package/dist/transports/stdio.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "../server/index.js";
+console.error("Starting default (STDIO) server...");
+/**
+ * The main method
+ * - Initializes the StdioServerTransport, sets up the server,
+ * - Handles cleanup on process exit.
+ *
+ * @return {Promise<void>} A promise that resolves when the main function has executed and the process exits.
+ */
+async function main() {
+    const transport = new StdioServerTransport();
+    const { server, cleanup } = createServer();
+    // Connect transport to server
+    await server.connect(transport);
+    // Cleanup on exit
+    process.on("SIGINT", async () => {
+        await server.close();
+        cleanup();
+        process.exit(0);
+    });
+}
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});