@modelcontextprotocol/server-everything 2025.12.18 → 2026.1.26

package/dist/tools/get-resource-links.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { textResource, textResourceUri, blobResourceUri, blobResource, } from "../resources/templates.js";
+// Tool input schema
+const GetResourceLinksSchema = z.object({
+    count: z
+        .number()
+        .min(1)
+        .max(10)
+        .default(3)
+        .describe("Number of resource links to return (1-10)"),
+});
+// Tool configuration
+const name = "get-resource-links";
+const config = {
+    title: "Get Resource Links Tool",
+    description: "Returns up to ten resource links that reference different types of resources",
+    inputSchema: GetResourceLinksSchema,
+};
+/**
+ * Registers the 'get-resource-reference' tool.
+ *
+ * The registered tool retrieves a specified number of resource links and their metadata.
+ * Resource links are dynamically generated as either text or binary blob resources,
+ * based on their ID being even or odd.
+
+ * The response contains a "text" introductory block and multiple "resource_link" blocks.
+ *
+ * @param {McpServer} server - The McpServer instance where the tool will be registered.
+ */
+export const registerGetResourceLinksTool = (server) => {
+    server.registerTool(name, config, async (args) => {
+        const { count } = GetResourceLinksSchema.parse(args);
+        // Add intro text content block
+        const content = [];
+        content.push({
+            type: "text",
+            text: `Here are ${count} resource links to resources available in this server:`,
+        });
+        // Create resource link content blocks
+        for (let resourceId = 1; resourceId <= count; resourceId++) {
+            // Get resource uri for text or blob resource based on odd/even resourceId
+            const isOdd = resourceId % 2 === 0;
+            const uri = isOdd
+                ? textResourceUri(resourceId)
+                : blobResourceUri(resourceId);
+            // Get resource based on the resource type
+            const resource = isOdd
+                ? textResource(uri, resourceId)
+                : blobResource(uri, resourceId);
+            content.push({
+                type: "resource_link",
+                uri: resource.uri,
+                name: `${isOdd ? "Text" : "Blob"} Resource ${resourceId}`,
+                description: `Resource ${resourceId}: ${resource.mimeType === "text/plain"
+                    ? "plaintext resource"
+                    : "binary blob resource"}`,
+                mimeType: resource.mimeType,
+            });
+        }
+        return { content };
+    });
+};

package/dist/tools/get-resource-reference.js

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { textResource, textResourceUri, blobResourceUri, blobResource, RESOURCE_TYPE_BLOB, RESOURCE_TYPE_TEXT, RESOURCE_TYPES, } from "../resources/templates.js";
+// Tool input schema
+const GetResourceReferenceSchema = z.object({
+    resourceType: z
+        .enum([RESOURCE_TYPE_TEXT, RESOURCE_TYPE_BLOB])
+        .default(RESOURCE_TYPE_TEXT),
+    resourceId: z
+        .number()
+        .default(1)
+        .describe("ID of the text resource to fetch"),
+});
+// Tool configuration
+const name = "get-resource-reference";
+const config = {
+    title: "Get Resource Reference Tool",
+    description: "Returns a resource reference that can be used by MCP clients",
+    inputSchema: GetResourceReferenceSchema,
+};
+/**
+ * Registers the 'get-resource-reference' tool.
+ *
+ * The registered tool validates and processes arguments for retrieving a resource
+ * reference. Supported resource types include predefined `RESOURCE_TYPE_TEXT` and
+ * `RESOURCE_TYPE_BLOB`. The retrieved resource's reference will include the resource
+ * ID, type, and its associated URI.
+ *
+ * The tool performs the following operations:
+ * 1. Validates the `resourceType` argument to ensure it matches a supported type.
+ * 2. Validates the `resourceId` argument to ensure it is a finite positive integer.
+ * 3. Constructs a URI for the resource based on its type (text or blob).
+ * 4. Retrieves the resource and returns it in a content block.
+ *
+ * @param {McpServer} server - The McpServer instance where the tool will be registered.
+ */
+export const registerGetResourceReferenceTool = (server) => {
+    server.registerTool(name, config, async (args) => {
+        // Validate resource type argument
+        const { resourceType } = args;
+        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 {
+            content: [
+                {
+                    type: "text",
+                    text: `Returning resource reference for Resource ${resourceId}:`,
+                },
+                {
+                    type: "resource",
+                    resource: resource,
+                },
+                {
+                    type: "text",
+                    text: `You can access this resource using the URI: ${resource.uri}`,
+                },
+            ],
+        };
+    });
+};

package/dist/tools/get-roots-list.js

@@ -0,0 +1,71 @@
+import { syncRoots } from "../server/roots.js";
+// Tool configuration
+const name = "get-roots-list";
+const config = {
+    title: "Get Roots List Tool",
+    description: "Lists the current MCP roots provided by the client. Demonstrates the roots protocol capability even though this server doesn't access files.",
+    inputSchema: {},
+};
+/**
+ * Registers the 'get-roots-list' tool.
+ *
+ * If the client does not support the roots capability, the tool is not registered.
+ *
+ * The registered tool interacts with the MCP roots capability, which enables the server to access
+ * information about the client's workspace directories or file system roots.
+ *
+ * When supported, the server automatically retrieves and formats the current list of roots from the
+ * client upon connection and whenever the client sends a `roots/list_changed` notification.
+ *
+ * Therefore, this tool displays the roots that the server currently knows about for the connected
+ * client. If for some reason the server never got the initial roots list, the tool will request the
+ * list from the client again.
+ *
+ * @param {McpServer} server - The McpServer instance where the tool will be registered.
+ */
+export const registerGetRootsListTool = (server) => {
+    // Does client support roots?
+    const clientCapabilities = server.server.getClientCapabilities() || {};
+    const clientSupportsRoots = clientCapabilities.roots !== undefined;
+    // If so, register tool
+    if (clientSupportsRoots) {
+        server.registerTool(name, config, async (args, extra) => {
+            // Get the current rootsFetch the current roots list from the client if need be
+            const currentRoots = await syncRoots(server, extra.sessionId);
+            // Respond if client supports roots but doesn't have any configured
+            if (clientSupportsRoots &&
+                (!currentRoots || currentRoots.length === 0)) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "The client supports roots but no roots are currently configured.\n\n" +
+                                "This could mean:\n" +
+                                "1. The client hasn't provided any roots yet\n" +
+                                "2. The client provided an empty roots list\n" +
+                                "3. The roots configuration is still being loaded",
+                        },
+                    ],
+                };
+            }
+            // Create formatted response if there is a list of roots
+            const rootsList = currentRoots
+                ? currentRoots
+                    .map((root, index) => {
+                    return `${index + 1}. ${root.name || "Unnamed Root"}\n   URI: ${root.uri}`;
+                })
+                    .join("\n\n")
+                : "No roots found";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Current MCP Roots (${currentRoots.length} total):\n\n${rootsList}\n\n` +
+                            "Note: This server demonstrates the roots protocol capability but doesn't actually access files. " +
+                            "The roots are provided by the MCP client and can be used by servers that need file system access.",
+                    },
+                ],
+            };
+        });
+    }
+};

package/dist/tools/get-structured-content.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+// Tool input schema
+const GetStructuredContentInputSchema = {
+    location: z
+        .enum(["New York", "Chicago", "Los Angeles"])
+        .describe("Choose city"),
+};
+// Tool output schema
+const GetStructuredContentOutputSchema = z.object({
+    temperature: z.number().describe("Temperature in celsius"),
+    conditions: z.string().describe("Weather conditions description"),
+    humidity: z.number().describe("Humidity percentage"),
+});
+// Tool configuration
+const name = "get-structured-content";
+const config = {
+    title: "Get Structured Content Tool",
+    description: "Returns structured content along with an output schema for client data validation",
+    inputSchema: GetStructuredContentInputSchema,
+    outputSchema: GetStructuredContentOutputSchema,
+};
+/**
+ * Registers the 'get-structured-content' tool.
+ *
+ * The registered tool processes incoming arguments using a predefined input schema,
+ * generates structured content with weather information including temperature,
+ * conditions, and humidity, and returns both backward-compatible content blocks
+ * and structured content in the response.
+ *
+ * The response contains:
+ * - `content`: An array of content blocks, presented as JSON stringified objects.
+ * - `structuredContent`: A JSON structured representation of the weather data.
+ *
+ * @param {McpServer} server - The McpServer instance where the tool will be registered.
+ */
+export const registerGetStructuredContentTool = (server) => {
+    server.registerTool(name, config, async (args) => {
+        // Get simulated weather for the chosen city
+        let weather;
+        switch (args.location) {
+            case "New York":
+                weather = {
+                    temperature: 33,
+                    conditions: "Cloudy",
+                    humidity: 82,
+                };
+                break;
+            case "Chicago":
+                weather = {
+                    temperature: 36,
+                    conditions: "Light rain / drizzle",
+                    humidity: 82,
+                };
+                break;
+            case "Los Angeles":
+                weather = {
+                    temperature: 73,
+                    conditions: "Sunny / Clear",
+                    humidity: 48,
+                };
+                break;
+        }
+        const backwardCompatibleContentBlock = {
+            type: "text",
+            text: JSON.stringify(weather),
+        };
+        return {
+            content: [backwardCompatibleContentBlock],
+            structuredContent: weather,
+        };
+    });
+};

package/dist/tools/get-sum.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+// Tool input schema
+const GetSumSchema = z.object({
+    a: z.number().describe("First number"),
+    b: z.number().describe("Second number"),
+});
+// Tool configuration
+const name = "get-sum";
+const config = {
+    title: "Get Sum Tool",
+    description: "Returns the sum of two numbers",
+    inputSchema: GetSumSchema,
+};
+/**
+ * Registers the 'get-sum' tool.
+ **
+ * The registered tool processes input arguments, validates them using a predefined schema,
+ * calculates the sum of two numeric values, and returns the result in a content block.
+ *
+ * Expects input arguments to conform to a specific schema that includes two numeric properties, `a` and `b`.
+ * Validation is performed to ensure the input adheres to the expected structure before calculating the sum.
+ *
+ * The result is returned as a Promise resolving to an object containing the computed sum in a text format.
+ *
+ * @param {McpServer} server - The McpServer instance where the tool will be registered.
+ */
+export const registerGetSumTool = (server) => {
+    server.registerTool(name, config, async (args) => {
+        const validatedArgs = GetSumSchema.parse(args);
+        const sum = validatedArgs.a + validatedArgs.b;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `The sum of ${validatedArgs.a} and ${validatedArgs.b} is ${sum}.`,
+                },
+            ],
+        };
+    });
+};

package/dist/tools/get-tiny-image.js

@@ -0,0 +1,41 @@
+// A tiny encoded MCP logo image
+export const MCP_TINY_IMAGE = "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";
+// Tool configuration
+const name = "get-tiny-image";
+const config = {
+    title: "Get Tiny Image Tool",
+    description: "Returns a tiny MCP logo image.",
+    inputSchema: {},
+};
+/**
+ * Registers the "get-tiny-image" tool.
+ *
+ * The registered tool returns a response containing a small image alongside some
+ * descriptive text.
+ *
+ * The response structure includes textual content before and after the image.
+ * The image is served as a PNG data type and represents the default MCP tiny image.
+ *
+ * @param server - The McpServer instance where the tool will be registered.
+ */
+export const registerGetTinyImageTool = (server) => {
+    server.registerTool(name, config, async (args) => {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Here's the image you requested:",
+                },
+                {
+                    type: "image",
+                    data: MCP_TINY_IMAGE,
+                    mimeType: "image/png",
+                },
+                {
+                    type: "text",
+                    text: "The image above is the MCP logo.",
+                },
+            ],
+        };
+    });
+};

package/dist/tools/gzip-file-as-resource.js

@@ -0,0 +1,182 @@
+import { z } from "zod";
+import { gzipSync } from "node:zlib";
+import { getSessionResourceURI, registerSessionResource, } from "../resources/session.js";
+// Maximum input file size - 10 MB default
+const GZIP_MAX_FETCH_SIZE = Number(process.env.GZIP_MAX_FETCH_SIZE ?? String(10 * 1024 * 1024));
+// Maximum fetch time - 30 seconds default.
+const GZIP_MAX_FETCH_TIME_MILLIS = Number(process.env.GZIP_MAX_FETCH_TIME_MILLIS ?? String(30 * 1000));
+// Comma-separated list of allowed domains. Empty means all domains are allowed.
+const GZIP_ALLOWED_DOMAINS = (process.env.GZIP_ALLOWED_DOMAINS ?? "")
+    .split(",")
+    .map((d) => d.trim().toLowerCase())
+    .filter((d) => d.length > 0);
+// Tool input schema
+const GZipFileAsResourceSchema = z.object({
+    name: z.string().describe("Name of the output file").default("README.md.gz"),
+    data: z
+        .string()
+        .url()
+        .describe("URL or data URI of the file content to compress")
+        .default("https://raw.githubusercontent.com/modelcontextprotocol/servers/refs/heads/main/README.md"),
+    outputType: z
+        .enum(["resourceLink", "resource"])
+        .default("resourceLink")
+        .describe("How the resulting gzipped file should be returned. 'resourceLink' returns a link to a resource that can be read later, 'resource' returns a full resource object."),
+});
+// Tool configuration
+const name = "gzip-file-as-resource";
+const config = {
+    title: "GZip File as Resource Tool",
+    description: "Compresses a single file using gzip compression. Depending upon the selected output type, returns either the compressed data as a gzipped resource or a resource link, allowing it to be downloaded in a subsequent request during the current session.",
+    inputSchema: GZipFileAsResourceSchema,
+};
+/**
+ * Registers the `gzip-file-as-resource` tool.
+ *
+ * The registered tool compresses input data using gzip, and makes the resulting file accessible
+ * as a resource for the duration of the session.
+ *
+ * The tool supports two output types:
+ * - "resource": Returns the resource directly, including its URI, MIME type, and base64-encoded content.
+ * - "resourceLink": Returns a link to access the resource later.
+ *
+ * If an unrecognized `outputType` is provided, the tool throws an error.
+ *
+ * @param {McpServer} server - The McpServer instance where the tool will be registered.
+ * @throws {Error} Throws an error if an unknown output type is specified.
+ */
+export const registerGZipFileAsResourceTool = (server) => {
+    server.registerTool(name, config, async (args) => {
+        const { name, data: dataUri, outputType, } = GZipFileAsResourceSchema.parse(args);
+        // Validate data uri
+        const url = validateDataURI(dataUri);
+        // Fetch the data
+        const response = await fetchSafely(url, {
+            maxBytes: GZIP_MAX_FETCH_SIZE,
+            timeoutMillis: GZIP_MAX_FETCH_TIME_MILLIS,
+        });
+        // Compress the data using gzip
+        const inputBuffer = Buffer.from(response);
+        const compressedBuffer = gzipSync(inputBuffer);
+        // Create resource
+        const uri = getSessionResourceURI(name);
+        const blob = compressedBuffer.toString("base64");
+        const mimeType = "application/gzip";
+        const resource = { uri, name, mimeType };
+        // Register resource, get resource link in return
+        const resourceLink = registerSessionResource(server, resource, "blob", blob);
+        // Return the resource or a resource link that can be used to access this resource later
+        if (outputType === "resource") {
+            return {
+                content: [
+                    {
+                        type: "resource",
+                        resource: { uri, mimeType, blob },
+                    },
+                ],
+            };
+        }
+        else if (outputType === "resourceLink") {
+            return {
+                content: [resourceLink],
+            };
+        }
+        else {
+            throw new Error(`Unknown outputType: ${outputType}`);
+        }
+    });
+};
+/**
+ * Validates a given data URI to ensure it follows the appropriate protocols and rules.
+ *
+ * @param {string} dataUri - The data URI to validate. Must be an HTTP, HTTPS, or data protocol URL. If a domain is provided, it must match the allowed domains list if applicable.
+ * @return {URL} The validated and parsed URL object.
+ * @throws {Error} If the data URI does not use a supported protocol or does not meet allowed domains criteria.
+ */
+function validateDataURI(dataUri) {
+    // Validate Inputs
+    const url = new URL(dataUri);
+    try {
+        if (url.protocol !== "http:" &&
+            url.protocol !== "https:" &&
+            url.protocol !== "data:") {
+            throw new Error(`Unsupported URL protocol for ${dataUri}. Only http, https, and data URLs are supported.`);
+        }
+        if (GZIP_ALLOWED_DOMAINS.length > 0 &&
+            (url.protocol === "http:" || url.protocol === "https:")) {
+            const domain = url.hostname;
+            const domainAllowed = GZIP_ALLOWED_DOMAINS.some((allowedDomain) => {
+                return domain === allowedDomain || domain.endsWith(`.${allowedDomain}`);
+            });
+            if (!domainAllowed) {
+                throw new Error(`Domain ${domain} is not in the allowed domains list.`);
+            }
+        }
+    }
+    catch (error) {
+        throw new Error(`Error processing file ${dataUri}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return url;
+}
+/**
+ * Fetches data safely from a given URL while ensuring constraints on maximum byte size and timeout duration.
+ *
+ * @param {URL} url The URL to fetch data from.
+ * @param {Object} options An object containing options for the fetch operation.
+ * @param {number} options.maxBytes The maximum allowed size (in bytes) of the response. If the response exceeds this size, the operation will be aborted.
+ * @param {number} options.timeoutMillis The timeout duration (in milliseconds) for the fetch operation. If the fetch takes longer, it will be aborted.
+ * @return {Promise<ArrayBuffer>} A promise that resolves with the response as an ArrayBuffer if successful.
+ * @throws {Error} Throws an error if the response size exceeds the defined limit, the fetch times out, or the response is otherwise invalid.
+ */
+async function fetchSafely(url, { maxBytes, timeoutMillis }) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(`Fetching ${url} took more than ${timeoutMillis} ms and was aborted.`), timeoutMillis);
+    try {
+        // Fetch the data
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.body) {
+            throw new Error("No response body");
+        }
+        // Note: we can't trust the Content-Length header: a malicious or clumsy server could return much more data than advertised.
+        // We check it here for early bail-out, but we still need to monitor actual bytes read below.
+        const contentLengthHeader = response.headers.get("content-length");
+        if (contentLengthHeader != null) {
+            const contentLength = parseInt(contentLengthHeader, 10);
+            if (contentLength > maxBytes) {
+                throw new Error(`Content-Length for ${url} exceeds max of ${maxBytes}: ${contentLength}`);
+            }
+        }
+        // Read the fetched data from the response body
+        const reader = response.body.getReader();
+        const chunks = [];
+        let totalSize = 0;
+        // Read chunks until done
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                totalSize += value.length;
+                if (totalSize > maxBytes) {
+                    reader.cancel();
+                    throw new Error(`Response from ${url} exceeds ${maxBytes} bytes`);
+                }
+                chunks.push(value);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        // Combine chunks into a single buffer
+        const buffer = new Uint8Array(totalSize);
+        let offset = 0;
+        for (const chunk of chunks) {
+            buffer.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return buffer.buffer;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/tools/index.js

@@ -0,0 +1,50 @@
+import { registerGetAnnotatedMessageTool } from "./get-annotated-message.js";
+import { registerEchoTool } from "./echo.js";
+import { registerGetEnvTool } from "./get-env.js";
+import { registerGetResourceLinksTool } from "./get-resource-links.js";
+import { registerGetResourceReferenceTool } from "./get-resource-reference.js";
+import { registerGetRootsListTool } from "./get-roots-list.js";
+import { registerGetStructuredContentTool } from "./get-structured-content.js";
+import { registerGetSumTool } from "./get-sum.js";
+import { registerGetTinyImageTool } from "./get-tiny-image.js";
+import { registerGZipFileAsResourceTool } from "./gzip-file-as-resource.js";
+import { registerToggleSimulatedLoggingTool } from "./toggle-simulated-logging.js";
+import { registerToggleSubscriberUpdatesTool } from "./toggle-subscriber-updates.js";
+import { registerTriggerElicitationRequestTool } from "./trigger-elicitation-request.js";
+import { registerTriggerLongRunningOperationTool } from "./trigger-long-running-operation.js";
+import { registerTriggerSamplingRequestTool } from "./trigger-sampling-request.js";
+import { registerTriggerSamplingRequestAsyncTool } from "./trigger-sampling-request-async.js";
+import { registerTriggerElicitationRequestAsyncTool } from "./trigger-elicitation-request-async.js";
+import { registerSimulateResearchQueryTool } from "./simulate-research-query.js";
+/**
+ * Register the tools with the MCP server.
+ * @param server
+ */
+export const registerTools = (server) => {
+    registerEchoTool(server);
+    registerGetAnnotatedMessageTool(server);
+    registerGetEnvTool(server);
+    registerGetResourceLinksTool(server);
+    registerGetResourceReferenceTool(server);
+    registerGetStructuredContentTool(server);
+    registerGetSumTool(server);
+    registerGetTinyImageTool(server);
+    registerGZipFileAsResourceTool(server);
+    registerToggleSimulatedLoggingTool(server);
+    registerToggleSubscriberUpdatesTool(server);
+    registerTriggerLongRunningOperationTool(server);
+};
+/**
+ * Register the tools that are conditional upon client capabilities.
+ * These must be registered conditionally, after initialization.
+ */
+export const registerConditionalTools = (server) => {
+    registerGetRootsListTool(server);
+    registerTriggerElicitationRequestTool(server);
+    registerTriggerSamplingRequestTool(server);
+    // Task-based research tool (uses experimental tasks API)
+    registerSimulateResearchQueryTool(server);
+    // Bidirectional task tools - server sends requests that client executes as tasks
+    registerTriggerSamplingRequestAsyncTool(server);
+    registerTriggerElicitationRequestAsyncTool(server);
+};