@mcp-layer/test-server 0.0.0

package/src/tools/note-update.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+
+/**
+ * Register a tool that mutates note resources and emits update notifications.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @param {{ notes: Map<string, Record<string, string>> }} context
+ * @param {{ notifyResourceUpdated: (uri: string) => Promise<void> }} notifier
+ */
+export function registerNoteUpdate(server, context, notifier) {
+  const inputSchema = {
+    topic: z.string().min(1),
+    detail: z.string().min(1).default('summary'),
+    text: z.string().min(1)
+  };
+
+  /**
+   * Update the referenced note and broadcast notifications/resources/updated.
+   * @param {{ topic: string, detail: string, text: string }} args
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function updateNoteTool(args) {
+    const topic = args.topic.toLowerCase();
+    const entry = context.notes.get(topic) ?? {};
+    entry[args.detail] = args.text;
+    context.notes.set(topic, entry);
+    const uri = `note://${topic}/${args.detail}`;
+    await notifier.notifyResourceUpdated(uri);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Updated ${uri}.`
+        }
+      ],
+      structuredContent: {
+        uri,
+        text: args.text
+      }
+    };
+  }
+
+  server.registerTool(
+    'note-update',
+    {
+      title: 'Note Update',
+      description: 'Mutate note:// resources and trigger resources/updated notifications.',
+      inputSchema,
+      outputSchema: {
+        uri: z.string(),
+        text: z.string()
+      }
+    },
+    updateNoteTool
+  );
+}

package/src/tools/present.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+
+const PNG_BASE64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO3Z5wAAAABJRU5ErkJggg==';
+const WAV_BASE64 = 'UklGRiQAAABXQVZFZm10IBAAAAABAAEAESsAACJWAAACABAAZGF0YQAAAAA=';
+
+/**
+ * Register the present tool to emit mixed content types.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @returns {ReturnType<import('@modelcontextprotocol/sdk/server/mcp.js').McpServer['registerTool']>}
+ */
+export function registerPresent(server) {
+  const inputSchema = {
+    title: z.string().min(1, 'Title must be provided')
+  };
+
+  /**
+   * Emit markdown, image, audio, and resource link content items.
+   * @param {{ title: string }} args
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function presentTool(args) {
+    const markdown = `# ${args.title}\n\n- Alpha\n- Beta\n\n\`\`\`json\n{\"ok\":true}\n\`\`\``;
+    return {
+      content: [
+        {
+          type: 'text',
+          text: markdown,
+          mimeType: 'text/markdown'
+        },
+        {
+          type: 'image',
+          mimeType: 'image/png',
+          data: PNG_BASE64
+        },
+        {
+          type: 'audio',
+          mimeType: 'audio/wav',
+          data: WAV_BASE64
+        },
+        {
+          type: 'resource_link',
+          uri: 'resource://manual',
+          name: 'Server Manual',
+          description: 'Markdown manual for the test server.',
+          mimeType: 'text/markdown'
+        },
+        {
+          type: 'resource',
+          resource: {
+            uri: 'resource://manual',
+            mimeType: 'text/markdown',
+            text: '# Embedded Manual\n\nUse resources/read for the full manual.'
+          }
+        }
+      ],
+      structuredContent: {
+        title: args.title,
+        types: ['text', 'image', 'audio', 'resource_link', 'resource']
+      }
+    };
+  }
+
+  return server.registerTool(
+    'present',
+    {
+      title: 'Present',
+      description: 'Return mixed content types for CLI formatting.',
+      inputSchema,
+      outputSchema: {
+        title: z.string(),
+        types: z.array(z.string())
+      }
+    },
+    presentTool
+  );
+}

package/src/tools/progress.js

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+
+/**
+ * Register the progress tool that emits notifications/progress updates.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ */
+export function registerProgress(server) {
+  const inputSchema = {
+    steps: z.number().int().min(1).max(5).default(3),
+    delayMs: z.number().int().min(1).max(200).default(10)
+  };
+
+  /**
+   * Wait between steps and emit progress notifications when requested.
+   * @param {{ steps: number, delayMs: number }} args
+   * @param {{ _meta?: { progressToken?: string | number }, signal: AbortSignal, sendNotification: (notification: any) => Promise<void> }} extra
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function progressTool(args, extra) {
+    const token = extra?._meta?.progressToken;
+
+    /**
+     * Sleep helper respecting cancellation.
+     * @returns {Promise<void>}
+     */
+    function sleep() {
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, args.delayMs);
+        extra.signal.addEventListener(
+          'abort',
+          () => {
+            clearTimeout(timer);
+            reject(new Error('progress tool aborted'));
+          },
+          { once: true }
+        );
+      });
+    }
+
+    for (let index = 1; index <= args.steps; index += 1) {
+      if (extra.signal.aborted) {
+        throw new Error('progress tool aborted');
+      }
+      await sleep();
+      if (token) {
+        await extra.sendNotification({
+          method: 'notifications/progress',
+          params: {
+            progressToken: token,
+            progress: index,
+            total: args.steps,
+            message: `step ${index} of ${args.steps}`
+          }
+        });
+      }
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Completed ${args.steps} steps.`
+        }
+      ],
+      structuredContent: {
+        steps: args.steps,
+        sentProgress: Boolean(token)
+      }
+    };
+  }
+
+  server.registerTool(
+    'progress',
+    {
+      title: 'Progress',
+      description: 'Emit notifications/progress updates for long-running work.',
+      inputSchema,
+      outputSchema: {
+        steps: z.number().int().min(1),
+        sentProgress: z.boolean()
+      }
+    },
+    progressTool
+  );
+}

package/src/tools/rebalance.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+
+/**
+ * Register the rebalance tool that toggles core tool registrations to exercise debounced notifications.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @param {{ echo: ReturnType<import('@modelcontextprotocol/sdk/server/mcp.js').McpServer['registerTool']>, add: ReturnType<import('@modelcontextprotocol/sdk/server/mcp.js').McpServer['registerTool']> }} handles
+ */
+export function registerRebalance(server, handles) {
+  const inputSchema = {
+    cycles: z.number().int().min(1).max(5).default(2)
+  };
+
+  /**
+   * Toggle core tools repeatedly to demonstrate notification debouncing.
+   * @param {{ cycles: number }} args
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function rebalanceTool(args) {
+    for (let index = 0; index < args.cycles; index += 1) {
+      handles.echo.disable();
+      handles.add.disable();
+      handles.echo.enable();
+      handles.add.enable();
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Rebalanced core tools for ${args.cycles} cycles.`
+        }
+      ],
+      structuredContent: { cycles: args.cycles }
+    };
+  }
+
+  server.registerTool(
+    'rebalance',
+    {
+      title: 'Rebalance',
+      description: 'Batch enable/disable operations to test debounced notifications.',
+      inputSchema,
+      outputSchema: {
+        cycles: z.number().int().min(1)
+      }
+    },
+    rebalanceTool
+  );
+}

package/src/tools/roots.js

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+
+/**
+ * Register the roots tool that calls roots/list on capable clients.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @param {{ hasCapability: (capability: 'roots') => boolean }} capabilities
+ */
+export function registerRoots(server, capabilities) {
+  const inputSchema = {
+    includeMeta: z.boolean().default(false)
+  };
+
+  /**
+   * Request roots/list from the client to expose workspace locations.
+   * @param {{ includeMeta: boolean }} args
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function rootsTool(args) {
+    if (!capabilities.hasCapability('roots')) {
+      const notice = 'Connected client did not declare roots capability.';
+      return {
+        content: [
+          {
+            type: 'text',
+            text: notice
+          }
+        ],
+        structuredContent: {
+          count: 0,
+          roots: [],
+          usedCapability: false
+        }
+      };
+    }
+
+    try {
+      const result = await server.server.listRoots({});
+      const roots = result.roots.map(function mapRoots(entry) {
+        return {
+          uri: entry.uri,
+          name: entry.name ?? null,
+          meta: args.includeMeta ? entry._meta ?? null : null
+        };
+      });
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Received ${roots.length} roots from client.`
+          }
+        ],
+        structuredContent: {
+          count: roots.length,
+          roots,
+          usedCapability: true
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        content: [
+          {
+            type: 'text',
+            text: message
+          }
+        ],
+        structuredContent: {
+          count: 0,
+          roots: [],
+          usedCapability: true,
+          error: message
+        }
+      };
+    }
+  }
+
+  server.registerTool(
+    'roots',
+    {
+      title: 'Roots',
+      description: 'Call roots/list on capable clients.',
+      inputSchema,
+      outputSchema: {
+        count: z.number().int(),
+        roots: z.array(
+          z.object({
+            uri: z.string(),
+            name: z.string().nullable(),
+            meta: z.record(z.unknown()).nullable().optional()
+          })
+        ),
+        usedCapability: z.boolean(),
+        error: z.string().optional()
+      }
+    },
+    rootsTool
+  );
+}

package/src/tools/summaries.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+
+/**
+ * Register the summaries tool that delegates to sampling/createMessage.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @param {{ hasCapability: (capability: 'sampling') => boolean }} capabilities
+ */
+export function registerSummaries(server, capabilities) {
+  const inputSchema = {
+    text: z.string().min(1, 'Text is required'),
+    maxTokens: z.number().int().min(64).max(512).default(200)
+  };
+
+  /**
+   * Request a summary via sampling/createMessage when supported.
+   * @param {{ text: string, maxTokens: number }} args
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function summaryTool(args) {
+    if (!capabilities.hasCapability('sampling')) {
+      const notice = 'Connected client did not declare sampling capability.';
+      return {
+        content: [
+          {
+            type: 'text',
+            text: notice
+          }
+        ],
+        structuredContent: {
+          summary: notice,
+          usedSampling: false,
+          model: null
+        }
+      };
+    }
+
+    try {
+      const response = await server.server.createMessage({
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: `Summarize the following text in one sentence.\n\n${args.text}`
+            }
+          }
+        ],
+        maxTokens: args.maxTokens
+      });
+      const summaryText = response.content.type === 'text' ? response.content.text : 'Sampling produced non-text output.';
+      return {
+        content: [
+          {
+            type: 'text',
+            text: summaryText
+          }
+        ],
+        structuredContent: {
+          summary: summaryText,
+          usedSampling: true,
+          model: response.model
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        content: [
+          {
+            type: 'text',
+            text: message
+          }
+        ],
+        structuredContent: {
+          summary: message,
+          usedSampling: false,
+          model: null
+        }
+      };
+    }
+  }
+
+  server.registerTool(
+    'summaries',
+    {
+      title: 'Summaries',
+      description: 'Proxy sampling/createMessage to summarize text.',
+      inputSchema,
+      outputSchema: {
+        summary: z.string(),
+        usedSampling: z.boolean(),
+        model: z.string().nullable()
+      }
+    },
+    summaryTool
+  );
+}

package/src/transport/http.js

@@ -0,0 +1,77 @@
+import express from 'express';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { build } from '../index.js';
+
+/**
+ * Start an HTTP server that exposes Streamable HTTP and SSE transports.
+ * @param {{ port?: number }} [opts]
+ * @returns {Promise<{ close: () => Promise<void> }>}
+ */
+export async function startHttpServer(opts = {}) {
+  const port = opts.port ?? Number(process.env.PORT ?? 3000);
+  const app = express();
+  app.use(express.json({ limit: '1mb' }));
+
+  /** @type {Record<string, { transport: StreamableHTTPServerTransport, server: import('@modelcontextprotocol/sdk/server/mcp.js').McpServer }>} */
+  const httpSessions = {};
+  /** @type {Record<string, { transport: SSEServerTransport, server: import('@modelcontextprotocol/sdk/server/mcp.js').McpServer }>} */
+  const sseSessions = {};
+
+  function newSession() {
+    const transport = new StreamableHTTPServerTransport({
+      enableJsonResponse: true
+    });
+    const server = build();
+    return { transport, server };
+  }
+
+  app.post('/mcp', async (req, res) => {
+    const sessionId = req.headers['mcp-session-id'];
+    let session = sessionId ? httpSessions[sessionId] : undefined;
+
+    if (!session) {
+      session = newSession();
+      httpSessions[session.transport.sessionId] = session;
+      res.setHeader('Mcp-Session-Id', session.transport.sessionId);
+      res.on('close', () => {
+        void session.transport.close();
+        delete httpSessions[session.transport.sessionId];
+      });
+      await session.server.connect(session.transport);
+    }
+
+    await session.transport.handleRequest(req, res, req.body);
+  });
+
+  app.get('/sse', async (req, res) => {
+    const transport = new SSEServerTransport('/sse/messages', res);
+    const server = build();
+    sseSessions[transport.sessionId] = { transport, server };
+    res.on('close', () => {
+      void transport.close();
+      delete sseSessions[transport.sessionId];
+    });
+    await server.connect(transport);
+  });
+
+  app.post('/sse/messages', async (req, res) => {
+    const sessionId = req.query.sessionId;
+    const session = typeof sessionId === 'string' ? sseSessions[sessionId] : undefined;
+    if (!session) {
+      res.status(400).send('No SSE session found');
+      return;
+    }
+    await session.transport.handlePostMessage(req, res, req.body);
+  });
+
+  return new Promise(resolve => {
+    const listener = app.listen(port, () => {
+      resolve({
+        async close() {
+          await new Promise(r => listener.close(r));
+        }
+      });
+    });
+  });
+}