@modelcontextprotocol/server-everything 2026.1.14 → 2026.7.4

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

@@ -0,0 +1,172 @@
+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,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+};
+// 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.looseObject({
+                    status: z.string(),
+                    statusMessage: z.string().optional(),
+                }));
+                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

@@ -14,6 +14,12 @@ const config = {
     title: "Trigger Sampling Request Tool",
     description: "Trigger a Request from the Server for LLM Sampling",
     inputSchema: TriggerSamplingRequestSchema,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
 };
 /**
  * Registers the 'trigger-sampling-request' tool.

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

@@ -0,0 +1,169 @@
+import { randomUUID } from "node:crypto";
+import { ElicitResultSchema, UrlElicitationRequiredError, } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+// Tool input schema
+const TriggerUrlElicitationSchema = z.object({
+    url: z.string().url().describe("The URL the user should open"),
+    message: z
+        .string()
+        .default("Please open the link to complete this action.")
+        .describe("Message shown to the user before opening the URL"),
+    elicitationId: z
+        .string()
+        .optional()
+        .describe("Optional explicit elicitation ID. Defaults to a random UUID."),
+    errorPath: z
+        .boolean()
+        .default(false)
+        .describe("Controls which elicitation mechanism is used. " +
+        "When false (default), sends an elicitation/create request (request path). " +
+        "When true, throws a UrlElicitationRequiredError (MCP error code -32042) so the client handles " +
+        "the URL elicitation via the error path rather than waiting for a response. " +
+        "To clear the error, satisfy the prerequisite and retry this call with the same arguments; the " +
+        "retry ignores errorPath and proceeds, so the client does not loop on the same error."),
+});
+// Tool configuration
+const name = "trigger-url-elicitation";
+const config = {
+    title: "Trigger URL Elicitation Tool",
+    description: "Trigger a URL elicitation so the client can direct the user to a browser flow. " +
+        "Supports two mechanisms: the request path (elicitation/create, default) which awaits the user's " +
+        "response, and the error path (UrlElicitationRequiredError, -32042) which signals the client " +
+        "to handle URL elicitation via the error response. Set errorPath=true to use the error path.",
+    inputSchema: TriggerUrlElicitationSchema,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+};
+/**
+ * Tracks requests for which an error-path prerequisite has already been issued,
+ * keyed by the stable inputs a client resends when it retries the original tool
+ * call (session + URL + caller-supplied elicitationId).
+ *
+ * When the client satisfies the prerequisite and retries the same call, the
+ * matching entry lets us recognize the retry, ignore `errorPath`, and proceed
+ * via the request path instead of re-throwing `UrlElicitationRequiredError` —
+ * which would otherwise loop forever (throw -> client satisfies prerequisite ->
+ * retry -> throw -> ...).
+ *
+ * Demo simplification: entries are only removed on a recognized retry, so a
+ * client that triggers the error path and never retries leaves its key behind.
+ * That is acceptable for this reference server; a production implementation
+ * serving many long-lived sessions should evict entries (e.g. a
+ * `Map<string, timestamp>` with TTL-based cleanup).
+ */
+const issuedErrorPathElicitations = new Set();
+/**
+ * Test-only helper to reset the module-level error-path state between cases.
+ * Not part of the tool's public behavior.
+ */
+export const __resetIssuedErrorPathElicitations = () => issuedErrorPathElicitations.clear();
+/**
+ * Registers the 'trigger-url-elicitation' tool.
+ *
+ * This tool only registers when the client advertises URL-mode elicitation
+ * capability (clientCapabilities.elicitation.url).
+ *
+ * Depending on the `errorPath` argument it either:
+ *  - Sends an `elicitation/create` request and awaits the result (request path), or
+ *  - Throws a `UrlElicitationRequiredError` (MCP error -32042) carrying a
+ *    prerequisite elicitation for the client to handle (error path). When the
+ *    client satisfies the prerequisite and retries the same call, the retry
+ *    ignores `errorPath` and proceeds via the request path, so the client does
+ *    not loop on the same error.
+ *
+ * @param {McpServer} server - The McpServer instance where the tool will be registered.
+ */
+export const registerTriggerUrlElicitationTool = (server) => {
+    const clientCapabilities = server.server.getClientCapabilities() || {};
+    const clientElicitationCapabilities = clientCapabilities.elicitation;
+    const clientSupportsUrlElicitation = clientElicitationCapabilities?.url !== undefined;
+    if (clientSupportsUrlElicitation) {
+        server.registerTool(name, config, async (args, extra) => {
+            const { url, message, elicitationId: requestedElicitationId, errorPath, } = args;
+            const elicitationId = requestedElicitationId ?? randomUUID();
+            const sessionId = extra.sessionId ?? "default";
+            // Key the one-shot error-path marker on inputs the client resends
+            // verbatim when it retries the original tool call. A real client retries
+            // with the *same* arguments and does NOT echo the prerequisite's
+            // (server-generated) elicitationId, so we must key on stable inputs:
+            // the session, the requested URL, and the caller-supplied elicitationId
+            // (if any). Keying on the resolved/random elicitationId would change on
+            // every call and never match, re-throwing the prerequisite forever.
+            const errorPathKey = `${sessionId}\u0000${url}\u0000${requestedElicitationId ?? ""}`;
+            const elicitationParams = {
+                mode: "url",
+                url,
+                message,
+                elicitationId,
+            };
+            // Error path: signal the client via UrlElicitationRequiredError (-32042)
+            // so it handles a prerequisite URL elicitation before this request can
+            // proceed. Two things keep the client from looping forever:
+            //
+            //  1. The prerequisite points at a *different* URL than the one that
+            //     failed. Reusing the original `url` would make the client complete
+            //     the prerequisite, retry, and hit the same -32042 error endlessly.
+            //  2. We remember that we issued a prerequisite for this request. When
+            //     the client satisfies it and retries the same call, we recognize
+            //     the retry, *ignore* errorPath, and fall through to the request
+            //     path. Without this, the retry would re-enter the error path and
+            //     re-request the prerequisite URL — another loop.
+            if (errorPath) {
+                if (issuedErrorPathElicitations.has(errorPathKey)) {
+                    // Retry of a satisfied prerequisite: clear the one-shot marker and
+                    // ignore errorPath, falling through to the request path below.
+                    issuedErrorPathElicitations.delete(errorPathKey);
+                }
+                else {
+                    // Originating call: record that we issued a prerequisite for this
+                    // request, then signal the client via -32042.
+                    issuedErrorPathElicitations.add(errorPathKey);
+                    const prerequisiteElicitation = {
+                        mode: "url",
+                        url: "https://modelcontextprotocol.io",
+                        message: "Open this link to satisfy the prerequisite, then retry the request.",
+                        elicitationId: randomUUID(),
+                    };
+                    throw new UrlElicitationRequiredError([prerequisiteElicitation], "This request requires browser-based authorization.");
+                }
+            }
+            // Request path: send elicitation/create and await the user's response
+            const elicitationResult = await extra.sendRequest({
+                method: "elicitation/create",
+                params: elicitationParams,
+            }, ElicitResultSchema, { timeout: 10 * 60 * 1000 /* 10 minutes */ });
+            // Handle different response actions
+            const content = [];
+            if (elicitationResult.action === "accept") {
+                content.push({
+                    type: "text",
+                    text: `✅ User completed the URL elicitation flow.\n` +
+                        `Elicitation ID: ${elicitationId}\n` +
+                        `URL: ${url}`,
+                });
+            }
+            else if (elicitationResult.action === "decline") {
+                content.push({
+                    type: "text",
+                    text: `❌ User declined to open the URL (Elicitation ID: ${elicitationId}).`,
+                });
+            }
+            else if (elicitationResult.action === "cancel") {
+                content.push({
+                    type: "text",
+                    text: `⚠️ User cancelled the URL elicitation (Elicitation ID: ${elicitationId}).`,
+                });
+            }
+            // Include raw result for debugging
+            content.push({
+                type: "text",
+                text: `\nRaw result: ${JSON.stringify(elicitationResult, null, 2)}`,
+            });
+            return { content };
+        });
+    }
+};

package/dist/transports/streamableHttp.js

@@ -1,9 +1,30 @@
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { InMemoryEventStore } from "@modelcontextprotocol/sdk/examples/shared/inMemoryEventStore.js";
+import { StreamableHTTPServerTransport, } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import express from "express";
 import { createServer } from "../server/index.js";
 import { randomUUID } from "node:crypto";
 import cors from "cors";
+// Simple in-memory event store for SSE resumability
+class InMemoryEventStore {
+    events = new Map();
+    async storeEvent(streamId, message) {
+        const eventId = randomUUID();
+        this.events.set(eventId, { streamId, message });
+        return eventId;
+    }
+    async replayEventsAfter(lastEventId, { send }) {
+        const entries = Array.from(this.events.entries());
+        const startIndex = entries.findIndex(([id]) => id === lastEventId);
+        if (startIndex === -1)
+            return lastEventId;
+        let lastId = lastEventId;
+        for (let i = startIndex + 1; i < entries.length; i++) {
+            const [eventId, { message }] = entries[i];
+            await send(eventId, message);
+            lastId = eventId;
+        }
+        return lastId;
+    }
+}
 console.log("Starting Streamable HTTP server...");
 // Express app with permissive CORS for testing with Inspector direct connect mode
 const app = express();

package/dist/vitest.config.js

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['**/__tests__/**/*.test.ts'],
+        coverage: {
+            provider: 'v8',
+            include: ['**/*.ts'],
+            exclude: ['**/__tests__/**', '**/dist/**'],
+        },
+    },
+});

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@modelcontextprotocol/server-everything",
-  "version": "2026.1.14",
+  "version": "2026.7.4",
   "description": "MCP server that exercises all the features of the MCP protocol",
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
   "mcpName": "io.github.modelcontextprotocol/server-everything",
-  "author": "Anthropic, PBC (https://anthropic.com)",
+  "author": "Model Context Protocol a Series of LF Projects, LLC.",
   "homepage": "https://modelcontextprotocol.io",
   "bugs": "https://github.com/modelcontextprotocol/servers/issues",
   "repository": {
@@ -26,21 +26,23 @@
     "start:sse": "node dist/index.js sse",
     "start:streamableHttp": "node dist/index.js streamableHttp",
     "prettier:fix": "prettier --write .",
-    "prettier:check": "prettier --check ."
+    "prettier:check": "prettier --check .",
+    "test": "vitest run --coverage"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.2",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "cors": "^2.8.5",
     "express": "^5.2.1",
     "jszip": "^3.10.1",
-    "zod": "^3.25.0",
-    "zod-to-json-schema": "^3.23.5"
+    "zod": "^4.0.0"
   },
   "devDependencies": {
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.6",
+    "@vitest/coverage-v8": "^4.1.8",
+    "prettier": "^2.8.8",
     "shx": "^0.3.4",
     "typescript": "^5.6.2",
-    "prettier": "^2.8.8"
+    "vitest": "^4.1.8"
   }
 }