@mcpflo/server-everything 0.0.1

package/dist/resources/templates.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourceIdForPromptCompleter = exports.resourceTypeCompleter = exports.RESOURCE_TYPES = exports.RESOURCE_TYPE_BLOB = exports.RESOURCE_TYPE_TEXT = void 0;
+exports.textResourceUri = textResourceUri;
+exports.blobResourceUri = blobResourceUri;
+exports.textResource = textResource;
+exports.blobResource = blobResource;
+exports.registerResourceTemplates = registerResourceTemplates;
+const zod_1 = require("zod");
+const completable_js_1 = require("@modelcontextprotocol/sdk/server/completable.js");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+exports.RESOURCE_TYPE_TEXT = 'text';
+exports.RESOURCE_TYPE_BLOB = 'blob';
+exports.RESOURCE_TYPES = [exports.RESOURCE_TYPE_TEXT, exports.RESOURCE_TYPE_BLOB];
+function textResourceUri(id) {
+    return `mcpflo://static/resource/text/${id}`;
+}
+function blobResourceUri(id) {
+    return `mcpflo://static/resource/blob/${id}`;
+}
+function textResource(uri, id) {
+    return {
+        uri,
+        mimeType: 'text/plain',
+        text: `Resource ${id}: this is a plaintext demo/test fixture resource.`
+    };
+}
+function blobResource(uri, id) {
+    const text = `Resource ${id}: this is a binary demo/test fixture resource.`;
+    return {
+        uri,
+        mimeType: 'application/octet-stream',
+        blob: Buffer.from(text, 'utf-8').toString('base64')
+    };
+}
+exports.resourceTypeCompleter = (0, completable_js_1.completable)(zod_1.z.enum(exports.RESOURCE_TYPES).describe('Type of resource: text or blob'), (value) => exports.RESOURCE_TYPES.filter((t) => t.startsWith(value)));
+// resourceId stays a plain completable string, not a coerced number: prompt
+// argument values always arrive as strings over the wire, and completion
+// candidates need to be strings too — the numeric conversion happens where
+// the value is actually used (see prompts/resource.ts), same as the
+// reference's own handler-side Number(...) conversion.
+exports.resourceIdForPromptCompleter = (0, completable_js_1.completable)(zod_1.z.string().describe('ID of the resource'), (value) => ['1', '2', '3', '4', '5'].filter((id) => id.startsWith(value)));
+// Distinct namespace from the static mcpflo://static/resource/... URIs above,
+// since these are genuinely different: dynamic MCP resource *templates*
+// (resources/templates/list), content regenerated with a live timestamp on
+// every read, deliberately excluded from resources/list (list: undefined).
+const DYNAMIC_TEXT_URI_TEMPLATE = 'mcpflo://dynamic/text/{resourceId}';
+const DYNAMIC_BLOB_URI_TEMPLATE = 'mcpflo://dynamic/blob/{resourceId}';
+const resourceIdForResourceTemplateCompleter = (value) => {
+    const resourceId = Number(value);
+    return Number.isInteger(resourceId) && resourceId > 0 ? [value] : [];
+};
+function parseResourceId(variables) {
+    const raw = Array.isArray(variables.resourceId) ? variables.resourceId[0] : variables.resourceId;
+    const resourceId = Number(raw);
+    if (!Number.isFinite(resourceId) || !Number.isInteger(resourceId) || resourceId < 1) {
+        throw new Error(`Invalid resourceId: ${raw}. Must be a finite positive integer.`);
+    }
+    return resourceId;
+}
+function dynamicTextContent(uri, resourceId) {
+    return {
+        uri: uri.toString(),
+        mimeType: 'text/plain',
+        text: `Resource ${resourceId}: dynamically generated plaintext resource, created at ${new Date().toISOString()}.`
+    };
+}
+function dynamicBlobContent(uri, resourceId) {
+    const text = `Resource ${resourceId}: dynamically generated binary resource, created at ${new Date().toISOString()}.`;
+    return {
+        uri: uri.toString(),
+        mimeType: 'application/octet-stream',
+        blob: Buffer.from(text, 'utf-8').toString('base64')
+    };
+}
+function registerResourceTemplates(server) {
+    server.registerResource('Dynamic Text Resource', new mcp_js_1.ResourceTemplate(DYNAMIC_TEXT_URI_TEMPLATE, {
+        list: undefined,
+        complete: { resourceId: resourceIdForResourceTemplateCompleter }
+    }), {
+        mimeType: 'text/plain',
+        description: 'Plaintext dynamic resource fabricated from the {resourceId} variable, which must be a positive integer. Demo/test fixture.'
+    }, async (uri, variables) => ({ contents: [dynamicTextContent(uri, parseResourceId(variables))] }));
+    server.registerResource('Dynamic Blob Resource', new mcp_js_1.ResourceTemplate(DYNAMIC_BLOB_URI_TEMPLATE, {
+        list: undefined,
+        complete: { resourceId: resourceIdForResourceTemplateCompleter }
+    }), {
+        mimeType: 'application/octet-stream',
+        description: 'Binary (base64) dynamic resource fabricated from the {resourceId} variable, which must be a positive integer. Demo/test fixture.'
+    }, async (uri, variables) => ({ contents: [dynamicBlobContent(uri, parseResourceId(variables))] }));
+}

package/dist/server/logging.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLoggingCapability = registerLoggingCapability;
+exports.beginSimulatedLogging = beginSimulatedLogging;
+exports.stopSimulatedLogging = stopSimulatedLogging;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+// RFC 5424 severity, lowest number = most severe.
+const LEVEL_SEVERITY = {
+    emergency: 0,
+    alert: 1,
+    critical: 2,
+    error: 3,
+    warning: 4,
+    notice: 5,
+    info: 6,
+    debug: 7
+};
+const RANDOM_LEVELS = Object.keys(LEVEL_SEVERITY);
+const INTERVAL_MS = 5000;
+const sessionLevels = new Map();
+const sessionTimers = new Map();
+function registerLoggingCapability(server) {
+    server.server.setRequestHandler(types_js_1.SetLevelRequestSchema, async (request, extra) => {
+        sessionLevels.set(extra.sessionId, request.params.level);
+        return {};
+    });
+}
+function beginSimulatedLogging(server, sessionId) {
+    const timer = setInterval(() => {
+        const level = RANDOM_LEVELS[Math.floor(Math.random() * RANDOM_LEVELS.length)];
+        const minLevel = sessionLevels.get(sessionId) ?? 'debug';
+        if (LEVEL_SEVERITY[level] > LEVEL_SEVERITY[minLevel])
+            return;
+        server.server
+            .sendLoggingMessage({ level, logger: 'simulated-logging', data: `Simulated ${level} message at ${new Date().toISOString()}` }, sessionId)
+            .catch(() => { });
+    }, INTERVAL_MS);
+    sessionTimers.set(sessionId, timer);
+}
+function stopSimulatedLogging(sessionId) {
+    const timer = sessionTimers.get(sessionId);
+    if (timer)
+        clearInterval(timer);
+    sessionTimers.delete(sessionId);
+}

package/dist/server/roots.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncRoots = syncRoots;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+// Track roots by session id. stdio is single-session (sessionId always
+// undefined), so setNotificationHandler below only ever gets called once for
+// the life of the process — if this server ever grew a multi-session
+// transport, the notification handler would need per-session dispatch
+// instead of relying on setNotificationHandler's single global registration.
+const roots = new Map();
+/**
+ * Gets the latest client roots list for the session, requesting and caching
+ * it on first use, then keeping the cache fresh via roots/list_changed.
+ * Idempotent: only requests roots from the client once per session.
+ */
+async function syncRoots(server, sessionId) {
+    const clientCapabilities = server.server.getClientCapabilities() ?? {};
+    if (clientCapabilities.roots === undefined)
+        return undefined;
+    const requestRoots = async () => {
+        try {
+            const response = await server.server.listRoots();
+            if (response && 'roots' in response) {
+                roots.set(sessionId, response.roots);
+                await server.sendLoggingMessage({
+                    level: 'info',
+                    logger: 'everything-server',
+                    data: `Roots updated: ${response.roots.length} root(s) received from client`
+                }, sessionId);
+            }
+            else {
+                await server.sendLoggingMessage({ level: 'info', logger: 'everything-server', data: 'Client returned no roots set' }, sessionId);
+            }
+        }
+        catch (error) {
+            console.error(`Failed to request roots from client ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    if (!roots.has(sessionId)) {
+        server.server.setNotificationHandler(types_js_1.RootsListChangedNotificationSchema, requestRoots);
+        await requestRoots();
+    }
+    return roots.get(sessionId);
+}

package/dist/tools/add.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAdd = registerAdd;
+const zod_1 = require("zod");
+function registerAdd(server) {
+    server.registerTool('add', {
+        description: 'Adds two numbers. Demo/test fixture.',
+        inputSchema: { a: zod_1.z.number(), b: zod_1.z.number() }
+    }, async ({ a, b }) => ({
+        content: [{ type: 'text', text: `${a} + ${b} = ${a + b}` }]
+    }));
+}

package/dist/tools/annotated-message.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAnnotatedMessage = registerAnnotatedMessage;
+const zod_1 = require("zod");
+const get_tiny_image_1 = require("./get-tiny-image");
+const AnnotatedMessageSchema = {
+    messageType: zod_1.z
+        .enum(['error', 'success', 'debug'])
+        .describe('Type of message to demonstrate different annotation patterns'),
+    includeImage: zod_1.z.boolean().default(false).describe('Whether to include an example image')
+};
+function registerAnnotatedMessage(server) {
+    server.registerTool('annotated-message', {
+        description: 'Returns content with audience/priority annotations. Demo/test fixture.',
+        inputSchema: AnnotatedMessageSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async ({ messageType, includeImage }) => {
+        const content = [];
+        if (messageType === 'error') {
+            content.push({
+                type: 'text',
+                text: 'Error: Operation failed',
+                annotations: {
+                    priority: 1.0,
+                    audience: ['user', 'assistant']
+                }
+            });
+        }
+        else if (messageType === 'success') {
+            content.push({
+                type: 'text',
+                text: 'Operation completed successfully',
+                annotations: {
+                    priority: 0.7,
+                    audience: ['user']
+                }
+            });
+        }
+        else {
+            content.push({
+                type: 'text',
+                text: 'Debug: Cache hit ratio 0.95, latency 150ms',
+                annotations: {
+                    priority: 0.3,
+                    audience: ['assistant']
+                }
+            });
+        }
+        if (includeImage) {
+            content.push({
+                type: 'image',
+                data: get_tiny_image_1.TINY_MCPFLO_IMAGE,
+                mimeType: 'image/png',
+                annotations: {
+                    priority: 0.5,
+                    audience: ['user']
+                }
+            });
+        }
+        return { content };
+    });
+}

package/dist/tools/echo.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEcho = registerEcho;
+const zod_1 = require("zod");
+function registerEcho(server) {
+    server.registerTool('echo', {
+        description: 'Echoes the message back. Demo/test fixture.',
+        inputSchema: { message: zod_1.z.string() }
+    }, async ({ message }) => ({
+        content: [{ type: 'text', text: `Echo: ${message}` }]
+    }));
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGetResourceLinks = registerGetResourceLinks;
+const zod_1 = require("zod");
+const templates_1 = require("../resources/templates");
+function registerGetResourceLinks(server) {
+    server.registerTool('get-resource-links', {
+        description: 'Returns up to ten resource links that reference different types of resources. Demo/test fixture.',
+        inputSchema: {
+            count: zod_1.z.number().min(1).max(10).default(3).describe('Number of resource links to return (1-10)')
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async ({ count }) => {
+        const content = [
+            { type: 'text', text: `Here are ${count} resource links to resources available in this server:` }
+        ];
+        for (let resourceId = 1; resourceId <= count; resourceId++) {
+            const isEven = resourceId % 2 === 0;
+            const uri = isEven ? (0, templates_1.textResourceUri)(resourceId) : (0, templates_1.blobResourceUri)(resourceId);
+            const resource = isEven ? (0, templates_1.textResource)(uri, resourceId) : (0, templates_1.blobResource)(uri, resourceId);
+            content.push({
+                type: 'resource_link',
+                uri: resource.uri,
+                name: `${isEven ? '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,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGetResourceReference = registerGetResourceReference;
+const zod_1 = require("zod");
+const templates_1 = require("../resources/templates");
+function registerGetResourceReference(server) {
+    server.registerTool('get-resource-reference', {
+        description: 'Returns a resource reference that can be used by MCP clients. Demo/test fixture.',
+        inputSchema: {
+            resourceType: zod_1.z.enum([templates_1.RESOURCE_TYPE_TEXT, templates_1.RESOURCE_TYPE_BLOB]).default(templates_1.RESOURCE_TYPE_TEXT),
+            resourceId: zod_1.z.number().int().positive().default(1).describe('ID of the resource to fetch')
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async ({ resourceType, resourceId }) => {
+        const uri = resourceType === templates_1.RESOURCE_TYPE_TEXT ? (0, templates_1.textResourceUri)(resourceId) : (0, templates_1.blobResourceUri)(resourceId);
+        const resource = resourceType === templates_1.RESOURCE_TYPE_TEXT
+            ? (0, templates_1.textResource)(uri, resourceId)
+            : (0, templates_1.blobResource)(uri, resourceId);
+        return {
+            content: [
+                { type: 'text', text: `Returning resource reference for Resource ${resourceId}:` },
+                { type: '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,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGetRootsList = registerGetRootsList;
+const roots_1 = require("../server/roots");
+function registerGetRootsList(server) {
+    // Called from server.server.oninitialized (see index.ts), so the client's
+    // capabilities are already known here — this is not a registration-time
+    // race like it would be if called eagerly at server construction.
+    const clientCapabilities = server.server.getClientCapabilities() ?? {};
+    if (clientCapabilities.roots === undefined)
+        return;
+    server.registerTool('get-roots-list', {
+        description: "Lists the current MCP roots provided by the client. Demonstrates the roots protocol " +
+            "capability even though this server doesn't access files. Demo/test fixture.",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async (extra) => {
+        const currentRoots = await (0, roots_1.syncRoots)(server, extra.sessionId);
+        if (!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'
+                    }
+                ]
+            };
+        }
+        const rootsList = currentRoots
+            .map((root, index) => `${index + 1}. ${root.name || 'Unnamed Root'}\n   URI: ${root.uri}`)
+            .join('\n\n');
+        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,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGetStructuredContent = registerGetStructuredContent;
+const zod_1 = require("zod");
+const LOCATIONS = ['New York', 'Chicago', 'Los Angeles'];
+const WEATHER_BY_LOCATION = {
+    'New York': { temperature: 33, conditions: 'Cloudy', humidity: 82 },
+    Chicago: { temperature: 36, conditions: 'Light rain / drizzle', humidity: 82 },
+    'Los Angeles': { temperature: 73, conditions: 'Sunny / Clear', humidity: 48 }
+};
+function registerGetStructuredContent(server) {
+    server.registerTool('get-structured-content', {
+        description: 'Returns structured content along with an output schema for client data validation. Demo/test fixture.',
+        inputSchema: {
+            location: zod_1.z.enum(LOCATIONS).describe('Choose city')
+        },
+        outputSchema: {
+            temperature: zod_1.z.number().describe('Temperature in celsius'),
+            conditions: zod_1.z.string().describe('Weather conditions description'),
+            humidity: zod_1.z.number().describe('Humidity percentage')
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async ({ location }) => {
+        const weather = WEATHER_BY_LOCATION[location];
+        return {
+            content: [{ type: 'text', text: JSON.stringify(weather) }],
+            structuredContent: weather
+        };
+    });
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TINY_MCPFLO_IMAGE = void 0;
+exports.registerGetTinyImage = registerGetTinyImage;
+// Tiny render of MCPFlo's hummingbird logo (resources/icon.png, downscaled to 24x24).
+exports.TINY_MCPFLO_IMAGE = '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';
+function registerGetTinyImage(server) {
+    server.registerTool('get-tiny-image', {
+        description: 'Returns a tiny render of the MCPFlo logo. Demo/test fixture.',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async () => ({
+        content: [
+            { type: 'text', text: "Here's the image you requested:" },
+            { type: 'image', data: exports.TINY_MCPFLO_IMAGE, mimeType: 'image/png' },
+            { type: 'text', text: 'The image above is the MCPFlo hummingbird logo.' }
+        ]
+    }));
+}

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

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGzipFileAsResource = registerGzipFileAsResource;
+const zod_1 = require("zod");
+const node_zlib_1 = require("node:zlib");
+const session_1 = require("../resources/session");
+const GZIP_MAX_FETCH_SIZE = Number(process.env.GZIP_MAX_FETCH_SIZE ?? String(10 * 1024 * 1024));
+const GZIP_MAX_FETCH_TIME_MILLIS = Number(process.env.GZIP_MAX_FETCH_TIME_MILLIS ?? String(30 * 1000));
+const GZIP_ALLOWED_DOMAINS = (process.env.GZIP_ALLOWED_DOMAINS ?? '')
+    .split(',')
+    .map((d) => d.trim().toLowerCase())
+    .filter((d) => d.length > 0);
+function registerGzipFileAsResource(server) {
+    server.registerTool('gzip-file-as-resource', {
+        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. Demo/test fixture.",
+        inputSchema: {
+            name: zod_1.z.string().describe('Name of the output file').default('README.md.gz'),
+            data: zod_1.z
+                .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: zod_1.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.")
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true
+        }
+    }, async ({ name, data: dataUri, outputType }) => {
+        const url = validateDataURI(dataUri);
+        const response = await fetchSafely(url, {
+            maxBytes: GZIP_MAX_FETCH_SIZE,
+            timeoutMillis: GZIP_MAX_FETCH_TIME_MILLIS
+        });
+        const compressedBuffer = (0, node_zlib_1.gzipSync)(Buffer.from(response));
+        const uri = (0, session_1.getSessionResourceURI)(name);
+        const blob = compressedBuffer.toString('base64');
+        const mimeType = 'application/gzip';
+        const resource = { uri, name, mimeType };
+        const resourceLink = (0, session_1.registerSessionResource)(server, resource, 'blob', blob);
+        if (outputType === 'resource') {
+            return { content: [{ type: 'resource', resource: { uri, mimeType, blob } }] };
+        }
+        return { content: [resourceLink] };
+    });
+}
+function validateDataURI(dataUri) {
+    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) => 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;
+}
+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 {
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.body) {
+            throw new Error('No response body');
+        }
+        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}`);
+            }
+        }
+        const reader = response.body.getReader();
+        const chunks = [];
+        let totalSize = 0;
+        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();
+        }
+        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,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTools = registerTools;
+exports.registerConditionalTools = registerConditionalTools;
+const echo_1 = require("./echo");
+const add_1 = require("./add");
+const print_env_1 = require("./print-env");
+const get_tiny_image_1 = require("./get-tiny-image");
+const annotated_message_1 = require("./annotated-message");
+const get_resource_reference_1 = require("./get-resource-reference");
+const get_structured_content_1 = require("./get-structured-content");
+const get_resource_links_1 = require("./get-resource-links");
+const gzip_file_as_resource_1 = require("./gzip-file-as-resource");
+const toggle_simulated_logging_1 = require("./toggle-simulated-logging");
+const toggle_subscriber_updates_1 = require("./toggle-subscriber-updates");
+const trigger_long_running_operation_1 = require("./trigger-long-running-operation");
+const simulate_research_query_1 = require("./simulate-research-query");
+const trigger_elicitation_request_async_1 = require("./trigger-elicitation-request-async");
+const trigger_elicitation_request_1 = require("./trigger-elicitation-request");
+const trigger_sampling_request_async_1 = require("./trigger-sampling-request-async");
+const trigger_sampling_request_1 = require("./trigger-sampling-request");
+const trigger_url_elicitation_1 = require("./trigger-url-elicitation");
+const get_roots_list_1 = require("./get-roots-list");
+// Tools with no capability dependency — safe to register immediately at
+// server construction, before any client has connected.
+const registerFns = [
+    echo_1.registerEcho,
+    add_1.registerAdd,
+    print_env_1.registerPrintEnv,
+    get_tiny_image_1.registerGetTinyImage,
+    annotated_message_1.registerAnnotatedMessage,
+    get_resource_reference_1.registerGetResourceReference,
+    get_structured_content_1.registerGetStructuredContent,
+    get_resource_links_1.registerGetResourceLinks,
+    gzip_file_as_resource_1.registerGzipFileAsResource,
+    toggle_simulated_logging_1.registerToggleSimulatedLogging,
+    toggle_subscriber_updates_1.registerToggleSubscriberUpdates,
+    trigger_long_running_operation_1.registerTriggerLongRunningOperation
+];
+function registerTools(server) {
+    for (const register of registerFns) {
+        register(server);
+    }
+}
+// Tools that depend on a client-declared capability. Registered only from
+// server.server.oninitialized (see index.ts), once the client's actual
+// capabilities are known — registering these eagerly at construction time
+// would mean getClientCapabilities() always reads empty, and either the
+// tool never registers or a flag computed from it is permanently stale.
+const registerConditionalFns = [
+    get_roots_list_1.registerGetRootsList,
+    trigger_elicitation_request_1.registerTriggerElicitationRequest,
+    trigger_url_elicitation_1.registerTriggerUrlElicitation,
+    trigger_sampling_request_1.registerTriggerSamplingRequest,
+    simulate_research_query_1.registerSimulateResearchQuery,
+    trigger_sampling_request_async_1.registerTriggerSamplingRequestAsync,
+    trigger_elicitation_request_async_1.registerTriggerElicitationRequestAsync
+];
+function registerConditionalTools(server) {
+    for (const register of registerConditionalFns) {
+        register(server);
+    }
+}

package/dist/tools/print-env.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPrintEnv = registerPrintEnv;
+function registerPrintEnv(server) {
+    server.registerTool('print-env', {
+        description: 'Dumps the server process environment variables. Demo/test fixture.'
+    }, async () => ({
+        content: [{ type: 'text', text: JSON.stringify(process.env, null, 2) }]
+    }));
+}