@modelcontextprotocol/server-everything 2025.12.18 → 2026.1.26

package/dist/docs/structure.md

@@ -0,0 +1,182 @@
+# Everything Server - Project Structure
+
+**[Architecture](architecture.md)
+| Project Structure
+| [Startup Process](startup.md)
+| [Server Features](features.md)
+| [Extension Points](extension.md)
+| [How It Works](how-it-works.md)**
+
+```
+src/everything
+     ├── index.ts
+     ├── AGENTS.md
+     ├── package.json
+     ├── docs
+     │   ├── architecture.md
+     │   ├── extension.md
+     │   ├── features.md
+     │   ├── how-it-works.md
+     │   ├── instructions.md
+     │   ├── startup.md
+     │   └── structure.md
+     ├── prompts
+     │   ├── index.ts
+     │   ├── args.ts
+     │   ├── completions.ts
+     │   ├── simple.ts
+     │   └── resource.ts
+     ├── resources
+     │   ├── index.ts
+     │   ├── files.ts
+     │   ├── session.ts
+     │   ├── subscriptions.ts
+     │   └── templates.ts
+     ├── server
+     │   ├── index.ts
+     │   ├── logging.ts
+     │   └── roots.ts
+     ├── tools
+     │   ├── index.ts
+     │   ├── echo.ts
+     │   ├── get-annotated-message.ts
+     │   ├── get-env.ts
+     │   ├── get-resource-links.ts
+     │   ├── get-resource-reference.ts
+     │   ├── get-roots-list.ts
+     │   ├── get-structured-content.ts
+     │   ├── get-sum.ts
+     │   ├── get-tiny-image.ts
+     │   ├── gzip-file-as-resource.ts
+     │   ├── toggle-simulated-logging.ts
+     │   ├── toggle-subscriber-updates.ts
+     │   ├── trigger-elicitation-request.ts
+     │   ├── trigger-long-running-operation.ts
+     │   └── trigger-sampling-request.ts
+     └── transports
+         ├── sse.ts
+         ├── stdio.ts
+         └── streamableHttp.ts
+```
+
+# Project Contents
+
+## `src/everything`:
+
+### `index.ts`
+
+- CLI entry point that selects and runs a specific transport module based on the first CLI argument: `stdio`, `sse`, or `streamableHttp`.
+
+### `AGENTS.md`
+
+- Directions for Agents/LLMs explaining coding guidelines and how to appropriately extend the server.
+
+### `package.json`
+
+- Package metadata and scripts:
+  - `build`: TypeScript compile to `dist/`, copies `docs/` into `dist/` and marks the compiled entry scripts as executable.
+  - `start:stdio`, `start:sse`, `start:streamableHttp`: Run built transports from `dist/`.
+- Declares dependencies on `@modelcontextprotocol/sdk`, `express`, `cors`, `zod`, etc.
+
+### `docs/`
+
+- `architecture.md`
+  - This document.
+- `server-instructions.md`
+  - Human‑readable instructions intended to be passed to the client/LLM as for guidance on server use. Loaded by the server at startup and returned in the "initialize" exchange.
+
+### `prompts/`
+
+- `index.ts`
+  - `registerPrompts(server)` orchestrator; delegates to prompt factory/registration methods from in individual prompt files.
+- `simple.ts`
+  - Registers `simple-prompt`: a prompt with no arguments that returns a single user message.
+- `args.ts`
+  - Registers `args-prompt`: a prompt with two arguments (`city` required, `state` optional) used to compose a message.
+- `completions.ts`
+  - Registers `completable-prompt`: a prompt whose arguments support server-driven completions using the SDK’s `completable(...)` helper (e.g., completing `department` and context-aware `name`).
+- `resource.ts`
+  - Exposes `registerEmbeddedResourcePrompt(server)` which registers `resource-prompt` — a prompt that accepts `resourceType` ("Text" or "Blob") and `resourceId` (integer), and embeds a dynamically generated resource of the requested type within the returned messages. Internally reuses helpers from `resources/templates.ts`.
+
+### `resources/`
+
+- `index.ts`
+  - `registerResources(server)` orchestrator; delegates to resource factory/registration methods from individual resource files.
+- `templates.ts`
+  - Registers two dynamic, template‑driven resources using `ResourceTemplate`:
+    - Text: `demo://resource/dynamic/text/{index}` (MIME: `text/plain`)
+    - Blob: `demo://resource/dynamic/blob/{index}` (MIME: `application/octet-stream`, Base64 payload)
+  - The `{index}` path variable must be a finite positive integer. Content is generated on demand with a timestamp.
+  - Exposes helpers `textResource(uri, index)`, `textResourceUri(index)`, `blobResource(uri, index)`, and `blobResourceUri(index)` so other modules can construct and embed dynamic resources directly (e.g., from prompts).
+- `files.ts`
+  - Registers static file-based resources for each file in the `docs/` folder.
+  - URIs follow the pattern: `demo://resource/static/document/<filename>`.
+  - Serves markdown files as `text/markdown`, `.txt` as `text/plain`, `.json` as `application/json`, others default to `text/plain`.
+
+### `server/`
+
+- `index.ts`
+  - Server factory that creates an `McpServer` with declared capabilities, loads server instructions, and registers tools, prompts, and resources.
+  - Sets resource subscription handlers via `setSubscriptionHandlers(server)`.
+  - Exposes `{ server, cleanup }` to the chosen transport. Cleanup stops any running intervals in the server when the transport disconnects.
+- `logging.ts`
+  - Implements simulated logging. Periodically sends randomized log messages at various levels to the connected client session. Started/stopped on demand via a dedicated tool.
+
+### `tools/`
+
+- `index.ts`
+  - `registerTools(server)` orchestrator; delegates to tool factory/registration methods in individual tool files.
+- `echo.ts`
+  - Registers an `echo` tool that takes a message and returns `Echo: {message}`.
+- `get-annotated-message.ts`
+  - Registers an `annotated-message` tool which demonstrates annotated content items by emitting a primary `text` message with `annotations` that vary by `messageType` (`"error" | "success" | "debug"`), and optionally includes an annotated `image` (tiny PNG) when `includeImage` is true.
+- `get-env.ts`
+  - Registers a `get-env` tool that returns the current process environment variables as formatted JSON text; useful for debugging configuration.
+- `get-resource-links.ts`
+  - Registers a `get-resource-links` tool that returns an intro `text` block followed by multiple `resource_link` items.
+- `get-resource-reference.ts`
+  - Registers a `get-resource-reference` tool that returns a reference for a selected dynamic resource.
+- `get-roots-list.ts`
+  - Registers a `get-roots-list` tool that returns the last list of roots sent by the client.
+- `gzip-file-as-resource.ts`
+  - Registers a `gzip-file-as-resource` tool that fetches content from a URL or data URI, compresses it, and then either:
+    - returns a `resource_link` to a session-scoped resource (default), or
+    - returns an inline `resource` with the gzipped data. The resource will be still discoverable for the duration of the session via `resources/list`.
+  - Uses `resources/session.ts` to register the gzipped blob as a per-session resource at a URI like `demo://resource/session/<name>` with `mimeType: application/gzip`.
+  - Environment controls:
+    - `GZIP_MAX_FETCH_SIZE` (bytes, default 10 MiB)
+    - `GZIP_MAX_FETCH_TIME_MILLIS` (ms, default 30000)
+    - `GZIP_ALLOWED_DOMAINS` (comma-separated allowlist; empty means all domains allowed)
+- `trigger-elicitation-request.ts`
+  - Registers a `trigger-elicitation-request` tool that sends an `elicitation/create` request to the client/LLM and returns the elicitation result.
+- `trigger-sampling-request.ts`
+  - Registers a `trigger-sampling-request` tool that sends a `sampling/createMessage` request to the client/LLM and returns the sampling result.
+- `get-structured-content.ts`
+  - Registers a `get-structured-content` tool that demonstrates structuredContent block responses.
+- `get-sum.ts`
+  - Registers an `get-sum` tool with a Zod input schema that sums two numbers `a` and `b` and returns the result.
+- `get-tiny-image.ts`
+  - Registers a `get-tiny-image` tool, which returns a tiny PNG MCP logo as an `image` content item, along with surrounding descriptive `text` items.
+- `trigger-long-running-operation.ts`
+  - Registers a `long-running-operation` tool that simulates a long-running task over a specified `duration` (seconds) and number of `steps`; emits `notifications/progress` updates when the client supplies a `progressToken`.
+- `toggle-simulated-logging.ts`
+  - Registers a `toggle-simulated-logging` tool, which starts or stops simulated logging for the invoking session.
+- `toggle-subscriber-updates.ts`
+  - Registers a `toggle-subscriber-updates` tool, which starts or stops simulated resource subscription update checks for the invoking session.
+
+### `transports/`
+
+- `stdio.ts`
+  - Starts a `StdioServerTransport`, created the server via `createServer()`, and connects it.
+  - Handles `SIGINT` to close cleanly and calls `cleanup()` to remove any live intervals.
+- `sse.ts`
+  - Express server exposing:
+    - `GET /sse` to establish an SSE connection per session.
+    - `POST /message` for client messages.
+  - Manages multiple connected clients via a transport map.
+  - Starts an `SSEServerTransport`, created the server via `createServer()`, and connects it to a new transport.
+  - On server disconnect, calls `cleanup()` to remove any live intervals.
+- `streamableHttp.ts`
+  - Express server exposing a single `/mcp` endpoint for POST (JSON‑RPC), GET (SSE stream), and DELETE (session termination) using `StreamableHTTPServerTransport`.
+  - Uses an `InMemoryEventStore` for resumable sessions and tracks transports by `sessionId`.
+  - Connects a fresh server instance on initialization POST and reuses the transport for subsequent requests.

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 };
+};