@modelcontextprotocol/server-everything 2025.12.18 → 2026.1.14

package/dist/index.js

@@ -1,36 +1,41 @@
 #!/usr/bin/env node
 // Parse command line arguments first
 const args = process.argv.slice(2);
-const scriptName = args[0] || 'stdio';
+const scriptName = args[0] || "stdio";
 async function run() {
     try {
         // Dynamically import only the requested module to prevent all modules from initializing
         switch (scriptName) {
-            case 'stdio':
+            case "stdio":
                 // Import and run the default server
-                await import('./stdio.js');
+                await import("./transports/stdio.js");
                 break;
-            case 'sse':
+            case "sse":
                 // Import and run the SSE server
-                await import('./sse.js');
+                await import("./transports/sse.js");
                 break;
-            case 'streamableHttp':
+            case "streamableHttp":
                 // Import and run the streamable HTTP server
-                await import('./streamableHttp.js');
+                await import("./transports/streamableHttp.js");
                 break;
             default:
-                console.error(`Unknown script: ${scriptName}`);
-                console.log('Available scripts:');
-                console.log('- stdio');
-                console.log('- sse');
-                console.log('- streamableHttp');
+                console.error(`-`.repeat(53));
+                console.error(`  Everything Server Launcher`);
+                console.error(`  Usage: node ./index.js [stdio|sse|streamableHttp]`);
+                console.error(`  Default transport: stdio`);
+                console.error(`-`.repeat(53));
+                console.error(`Unknown transport: ${scriptName}`);
+                console.log("Available transports:");
+                console.log("- stdio");
+                console.log("- sse");
+                console.log("- streamableHttp");
                 process.exit(1);
         }
     }
     catch (error) {
-        console.error('Error running script:', error);
+        console.error("Error running script:", error);
         process.exit(1);
     }
 }
-run();
+await run();
 export {};

package/dist/prompts/args.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+/**
+ * Register a prompt with arguments
+ * - Two arguments, one required and one optional
+ * - Combines argument values in the returned prompt
+ *
+ * @param server
+ */
+export const registerArgumentsPrompt = (server) => {
+    // Prompt arguments
+    const promptArgsSchema = {
+        city: z.string().describe("Name of the city"),
+        state: z.string().describe("Name of the state").optional(),
+    };
+    // Register the prompt
+    server.registerPrompt("args-prompt", {
+        title: "Arguments Prompt",
+        description: "A prompt with two arguments, one required and one optional",
+        argsSchema: promptArgsSchema,
+    }, (args) => {
+        const location = `${args?.city}${args?.state ? `, ${args?.state}` : ""}`;
+        return {
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: `What's weather in ${location}?`,
+                    },
+                },
+            ],
+        };
+    });
+};

package/dist/prompts/completions.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { completable } from "@modelcontextprotocol/sdk/server/completable.js";
+/**
+ * Register a prompt with completable arguments
+ * - Two required arguments, both with completion handlers
+ * - First argument value will be included in context for second argument
+ * - Allows second argument to depend on the first argument value
+ *
+ * @param server
+ */
+export const registerPromptWithCompletions = (server) => {
+    // Prompt arguments
+    const promptArgsSchema = {
+        department: completable(z.string().describe("Choose the department."), (value) => {
+            return ["Engineering", "Sales", "Marketing", "Support"].filter((d) => d.startsWith(value));
+        }),
+        name: completable(z
+            .string()
+            .describe("Choose a team member to lead the selected department."), (value, context) => {
+            const department = context?.arguments?.["department"];
+            if (department === "Engineering") {
+                return ["Alice", "Bob", "Charlie"].filter((n) => n.startsWith(value));
+            }
+            else if (department === "Sales") {
+                return ["David", "Eve", "Frank"].filter((n) => n.startsWith(value));
+            }
+            else if (department === "Marketing") {
+                return ["Grace", "Henry", "Iris"].filter((n) => n.startsWith(value));
+            }
+            else if (department === "Support") {
+                return ["John", "Kim", "Lee"].filter((n) => n.startsWith(value));
+            }
+            return [];
+        }),
+    };
+    // Register the prompt
+    server.registerPrompt("completable-prompt", {
+        title: "Team Management",
+        description: "First argument choice narrows values for second argument.",
+        argsSchema: promptArgsSchema,
+    }, ({ department, name }) => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Please promote ${name} to the head of the ${department} team.`,
+                },
+            },
+        ],
+    }));
+};

package/dist/prompts/index.js

@@ -0,0 +1,15 @@
+import { registerSimplePrompt } from "./simple.js";
+import { registerArgumentsPrompt } from "./args.js";
+import { registerPromptWithCompletions } from "./completions.js";
+import { registerEmbeddedResourcePrompt } from "./resource.js";
+/**
+ * Register the prompts with the MCP server.
+ *
+ * @param server
+ */
+export const registerPrompts = (server) => {
+    registerSimplePrompt(server);
+    registerArgumentsPrompt(server);
+    registerPromptWithCompletions(server);
+    registerEmbeddedResourcePrompt(server);
+};

package/dist/prompts/resource.js

@@ -0,0 +1,60 @@
+import { resourceTypeCompleter, resourceIdForPromptCompleter, } from "../resources/templates.js";
+import { textResource, textResourceUri, blobResourceUri, blobResource, RESOURCE_TYPE_BLOB, RESOURCE_TYPE_TEXT, RESOURCE_TYPES, } from "../resources/templates.js";
+/**
+ * Register a prompt with an embedded resource reference
+ * - Takes a resource type and id
+ * - Returns the corresponding dynamically created resource
+ *
+ * @param server
+ */
+export const registerEmbeddedResourcePrompt = (server) => {
+    // Prompt arguments
+    const promptArgsSchema = {
+        resourceType: resourceTypeCompleter,
+        resourceId: resourceIdForPromptCompleter,
+    };
+    // Register the prompt
+    server.registerPrompt("resource-prompt", {
+        title: "Resource Prompt",
+        description: "A prompt that includes an embedded resource reference",
+        argsSchema: promptArgsSchema,
+    }, (args) => {
+        // Validate resource type argument
+        const resourceType = args.resourceType;
+        if (!RESOURCE_TYPES.includes(resourceType)) {
+            throw new Error(`Invalid resourceType: ${args?.resourceType}. Must be ${RESOURCE_TYPE_TEXT} or ${RESOURCE_TYPE_BLOB}.`);
+        }
+        // Validate resourceId argument
+        const resourceId = Number(args?.resourceId);
+        if (!Number.isFinite(resourceId) ||
+            !Number.isInteger(resourceId) ||
+            resourceId < 1) {
+            throw new Error(`Invalid resourceId: ${args?.resourceId}. Must be a finite positive integer.`);
+        }
+        // Get resource based on the resource type
+        const uri = resourceType === RESOURCE_TYPE_TEXT
+            ? textResourceUri(resourceId)
+            : blobResourceUri(resourceId);
+        const resource = resourceType === RESOURCE_TYPE_TEXT
+            ? textResource(uri, resourceId)
+            : blobResource(uri, resourceId);
+        return {
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: `This prompt includes the ${resourceType} resource with id: ${resourceId}. Please analyze the following resource:`,
+                    },
+                },
+                {
+                    role: "user",
+                    content: {
+                        type: "resource",
+                        resource: resource,
+                    },
+                },
+            ],
+        };
+    });
+};

package/dist/prompts/simple.js

@@ -0,0 +1,23 @@
+/**
+ * Register a simple prompt with no arguments
+ * - Returns the fixed text of the prompt with no modifications
+ *
+ * @param server
+ */
+export const registerSimplePrompt = (server) => {
+    // Register the prompt
+    server.registerPrompt("simple-prompt", {
+        title: "Simple Prompt",
+        description: "A prompt with no arguments",
+    }, () => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: "This is a simple prompt without arguments.",
+                },
+            },
+        ],
+    }));
+};

package/dist/resources/files.js

@@ -0,0 +1,83 @@
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { readdirSync, readFileSync, statSync } from "fs";
+/**
+ * Register static file resources
+ * - Each file in src/everything/docs is exposed as an individual static resource
+ * - URIs follow the pattern: "demo://static/docs/<filename>"
+ * - Markdown (.md) files are served as mime type "text/markdown"
+ * - Text (.txt) files are served as mime type "text/plain"
+ * - JSON (.json) files are served as mime type "application/json"
+ *
+ * @param server
+ */
+export const registerFileResources = (server) => {
+    // Read the entries in the docs directory
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const docsDir = join(__dirname, "..", "docs");
+    let entries = [];
+    try {
+        entries = readdirSync(docsDir);
+    }
+    catch (e) {
+        // If docs/ folder is missing or unreadable, just skip registration
+        return;
+    }
+    // Register each file as a static resource
+    for (const name of entries) {
+        // Only process files, not directories
+        const fullPath = join(docsDir, name);
+        try {
+            const st = statSync(fullPath);
+            if (!st.isFile())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        // Prepare file resource info
+        const uri = `demo://resource/static/document/${encodeURIComponent(name)}`;
+        const mimeType = getMimeType(name);
+        const description = `Static document file exposed from /docs: ${name}`;
+        // Register file resource
+        server.registerResource(name, uri, { mimeType, description }, async (uri) => {
+            const text = readFileSafe(fullPath);
+            return {
+                contents: [
+                    {
+                        uri: uri.toString(),
+                        mimeType,
+                        text,
+                    },
+                ],
+            };
+        });
+    }
+};
+/**
+ * Get the mimetype based on filename
+ * @param fileName
+ */
+function getMimeType(fileName) {
+    const lower = fileName.toLowerCase();
+    if (lower.endsWith(".md") || lower.endsWith(".markdown"))
+        return "text/markdown";
+    if (lower.endsWith(".txt"))
+        return "text/plain";
+    if (lower.endsWith(".json"))
+        return "application/json";
+    return "text/plain";
+}
+/**
+ * Read a file or return an error message if it fails
+ * @param path
+ */
+function readFileSafe(path) {
+    try {
+        return readFileSync(path, "utf-8");
+    }
+    catch (e) {
+        return `Error reading file: ${path}. ${e}`;
+    }
+}

package/dist/resources/index.js

@@ -0,0 +1,33 @@
+import { registerResourceTemplates } from "./templates.js";
+import { registerFileResources } from "./files.js";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { readFileSync } from "fs";
+/**
+ * Register the resources with the MCP server.
+ * @param server
+ */
+export const registerResources = (server) => {
+    registerResourceTemplates(server);
+    registerFileResources(server);
+};
+/**
+ * Reads the server instructions from the corresponding markdown file.
+ * Attempts to load the content of the file located in the `docs` directory.
+ * If the file cannot be loaded, an error message is returned instead.
+ *
+ * @return {string} The content of the server instructions file, or an error message if reading fails.
+ */
+export function readInstructions() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const filePath = join(__dirname, "..", "docs", "instructions.md");
+    let instructions;
+    try {
+        instructions = readFileSync(filePath, "utf-8");
+    }
+    catch (e) {
+        instructions = "Server instructions not loaded: " + e;
+    }
+    return instructions;
+}

package/dist/resources/session.js

@@ -0,0 +1,44 @@
+/**
+ * Generates a session-scoped resource URI string based on the provided resource name.
+ *
+ * @param {string} name - The name of the resource to create a URI for.
+ * @returns {string} The formatted session resource URI.
+ */
+export const getSessionResourceURI = (name) => {
+    return `demo://resource/session/${name}`;
+};
+/**
+ * Registers a session-scoped resource with the provided server and returns a resource link.
+ *
+ * The registered resource is available during the life of the session only; it is not otherwise persisted.
+ *
+ * @param {McpServer} server - The server instance responsible for handling the resource registration.
+ * @param {Resource} resource - The resource object containing metadata such as URI, name, description, and mimeType.
+ * @param {"text"|"blob"} type
+ * @param payload
+ * @returns {ResourceLink} An object representing the resource link, with associated metadata.
+ */
+export const registerSessionResource = (server, resource, type, payload) => {
+    // Destructure resource
+    const { uri, name, mimeType, description, title, annotations, icons, _meta } = resource;
+    // Prepare the resource content to return
+    // See https://modelcontextprotocol.io/specification/2025-11-25/server/resources#resource-contents
+    const resourceContent = type === "text"
+        ? {
+            uri: uri.toString(),
+            mimeType,
+            text: payload,
+        }
+        : {
+            uri: uri.toString(),
+            mimeType,
+            blob: payload,
+        };
+    // Register file resource
+    server.registerResource(name, uri, { mimeType, description, title, annotations, icons, _meta }, async (uri) => {
+        return {
+            contents: [resourceContent],
+        };
+    });
+    return { type: "resource_link", ...resource };
+};

package/dist/resources/subscriptions.js

@@ -0,0 +1,125 @@
+import { SubscribeRequestSchema, UnsubscribeRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+// Track subscriber session id lists by URI
+const subscriptions = new Map();
+// Interval to send notifications to subscribers
+const subsUpdateIntervals = new Map();
+/**
+ * Sets up the subscription and unsubscription handlers for the provided server.
+ *
+ * The function defines two request handlers:
+ * 1. A `Subscribe` handler that allows clients to subscribe to specific resource URIs.
+ * 2. An `Unsubscribe` handler that allows clients to unsubscribe from specific resource URIs.
+ *
+ * The `Subscribe` handler performs the following actions:
+ * - Extracts the URI and session ID from the request.
+ * - Logs a message acknowledging the subscription request.
+ * - Updates the internal tracking of subscribers for the given URI.
+ *
+ * The `Unsubscribe` handler performs the following actions:
+ * - Extracts the URI and session ID from the request.
+ * - Logs a message acknowledging the unsubscription request.
+ * - Removes the subscriber for the specified URI.
+ *
+ * @param {McpServer} server - The server instance to which subscription handlers will be attached.
+ */
+export const setSubscriptionHandlers = (server) => {
+    // Set the subscription handler
+    server.server.setRequestHandler(SubscribeRequestSchema, async (request, extra) => {
+        // Get the URI to subscribe to
+        const { uri } = request.params;
+        // Get the session id (can be undefined for stdio)
+        const sessionId = extra.sessionId;
+        // Acknowledge the subscribe request
+        await server.sendLoggingMessage({
+            level: "info",
+            data: `Received Subscribe Resource request for URI: ${uri} ${sessionId ? `from session ${sessionId}` : ""}`,
+        }, sessionId);
+        // Get the subscribers for this URI
+        const subscribers = subscriptions.has(uri)
+            ? subscriptions.get(uri)
+            : new Set();
+        subscribers.add(sessionId);
+        subscriptions.set(uri, subscribers);
+        return {};
+    });
+    // Set the unsubscription handler
+    server.server.setRequestHandler(UnsubscribeRequestSchema, async (request, extra) => {
+        // Get the URI to subscribe to
+        const { uri } = request.params;
+        // Get the session id (can be undefined for stdio)
+        const sessionId = extra.sessionId;
+        // Acknowledge the subscribe request
+        await server.sendLoggingMessage({
+            level: "info",
+            data: `Received Unsubscribe Resource request: ${uri} ${sessionId ? `from session ${sessionId}` : ""}`,
+        }, sessionId);
+        // Remove the subscriber
+        if (subscriptions.has(uri)) {
+            const subscribers = subscriptions.get(uri);
+            if (subscribers.has(sessionId))
+                subscribers.delete(sessionId);
+        }
+        return {};
+    });
+};
+/**
+ * Sends simulated resource update notifications to the subscribed client.
+ *
+ * This function iterates through all resource URIs stored in the subscriptions
+ * and checks if the specified session ID is subscribed to them. If so, it sends
+ * a notification through the provided server. If the session ID is no longer valid
+ * (disconnected), it removes the session ID from the list of subscribers.
+ *
+ * @param {McpServer} server - The server instance used to send notifications.
+ * @param {string | undefined} sessionId - The session ID of the client to check for subscriptions.
+ * @returns {Promise<void>} Resolves once all applicable notifications are sent.
+ */
+const sendSimulatedResourceUpdates = async (server, sessionId) => {
+    // Search all URIs for ones this client is subscribed to
+    for (const uri of subscriptions.keys()) {
+        const subscribers = subscriptions.get(uri);
+        // If this client is subscribed, send the notification
+        if (subscribers.has(sessionId)) {
+            await server.server.notification({
+                method: "notifications/resources/updated",
+                params: { uri },
+            });
+        }
+        else {
+            subscribers.delete(sessionId); // subscriber has disconnected
+        }
+    }
+};
+/**
+ * Starts the process of simulating resource updates and sending server notifications
+ * to the client for the resources they are subscribed to. If the update interval is
+ * already active, invoking this function will not start another interval.
+ *
+ * @param server
+ * @param sessionId
+ */
+export const beginSimulatedResourceUpdates = (server, sessionId) => {
+    if (!subsUpdateIntervals.has(sessionId)) {
+        // Send once immediately
+        sendSimulatedResourceUpdates(server, sessionId);
+        // Set the interval to send later resource update notifications to this client
+        subsUpdateIntervals.set(sessionId, setInterval(() => sendSimulatedResourceUpdates(server, sessionId), 5000));
+    }
+};
+/**
+ * Stops simulated resource updates for a given session.
+ *
+ * This function halts any active intervals associated with the provided session ID
+ * and removes the session's corresponding entries from resource management collections.
+ * Session ID can be undefined for stdio.
+ *
+ * @param {string} [sessionId]
+ */
+export const stopSimulatedResourceUpdates = (sessionId) => {
+    // Remove active intervals
+    if (subsUpdateIntervals.has(sessionId)) {
+        const subsUpdateInterval = subsUpdateIntervals.get(sessionId);
+        clearInterval(subsUpdateInterval);
+        subsUpdateIntervals.delete(sessionId);
+    }
+};