@mcp-layer/test-server 0.0.0

package/src/resources/ui.js

@@ -0,0 +1,58 @@
+const html = [
+  '<!doctype html>',
+  '<html lang="en">',
+  '  <head>',
+  '    <meta charset="utf-8" />',
+  '    <title>MCP Dashboard</title>',
+  '  </head>',
+  '  <body>',
+  '    <main>',
+  '      <h1>Dashboard</h1>',
+  '      <p>UI resource served via ui:// scheme.</p>',
+  '    </main>',
+  '  </body>',
+  '</html>',
+  ''
+].join('\n');
+
+const uri = 'ui://dashboard/app.html';
+
+/**
+ * Register the MCP App UI resource.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ */
+export function registerUi(server) {
+  /**
+   * Return HTML for the dashboard UI.
+   * @param {URL} url
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').ReadResourceResult>}
+   */
+  async function ui(url) {
+    return {
+      contents: [
+        {
+          uri: url.href,
+          mimeType: 'text/html',
+          text: html
+        }
+      ]
+    };
+  }
+
+  server.registerResource(
+    'dashboard-ui',
+    uri,
+    {
+      title: 'Dashboard UI',
+      description: 'MCP App UI for the dashboard tool.',
+      mimeType: 'text/html',
+      _meta: {
+        ui: {
+          csp: "default-src 'self'",
+          permissions: ['clipboard-read']
+        }
+      }
+    },
+    ui
+  );
+}

package/src/shared/capabilities.js

@@ -0,0 +1,18 @@
+/**
+ * Build a capability checker bound to the current server connection.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @returns {(capability: 'sampling' | 'elicitation' | 'roots') => boolean}
+ */
+export function createCapabilityChecker(server) {
+  /**
+   * Determine whether the connected client declared the requested capability.
+   * @param {'sampling' | 'elicitation' | 'roots'} capability
+   * @returns {boolean}
+   */
+  function hasCapability(capability) {
+    const caps = server.server.getClientCapabilities();
+    return Boolean(caps && caps[capability]);
+  }
+
+  return hasCapability;
+}

package/src/subscriptions/resources.js

@@ -0,0 +1,70 @@
+import { ErrorCode, McpError, SubscribeRequestSchema, UnsubscribeRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+
+/**
+ * Configure basic resource subscriptions on the underlying server transport.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @param {{ isSubscribable: (uri: string) => boolean }} options
+ * @returns {{ notifyResourceUpdated: (uri: string) => Promise<void> }}
+ */
+export function registerResourceSubscriptions(server, options) {
+  const subscribers = new Map();
+
+  server.server.assertCanSetRequestHandler(SubscribeRequestSchema.shape.method.value);
+  server.server.assertCanSetRequestHandler(UnsubscribeRequestSchema.shape.method.value);
+  server.server.registerCapabilities({
+    resources: {
+      subscribe: true
+    }
+  });
+
+  server.server.setRequestHandler(SubscribeRequestSchema, async (request, extra) => {
+    const uri = request.params.uri;
+    if (!options.isSubscribable(uri)) {
+      throw new McpError(ErrorCode.InvalidParams, `Cannot subscribe to ${uri}`);
+    }
+    const sessionId = extra.sessionId ?? 'stdio';
+    const existing = subscribers.get(sessionId) ?? new Set();
+    existing.add(uri);
+    subscribers.set(sessionId, existing);
+    return {};
+  });
+
+  server.server.setRequestHandler(UnsubscribeRequestSchema, async (request, extra) => {
+    const sessionId = extra.sessionId ?? 'stdio';
+    if (!sessionId) {
+      return {};
+    }
+    const set = subscribers.get(sessionId);
+    if (set) {
+      set.delete(request.params.uri);
+      if (set.size === 0) {
+        subscribers.delete(sessionId);
+      }
+    }
+    return {};
+  });
+
+  server.server.onclose = () => {
+    subscribers.clear();
+  };
+
+  /**
+   * Notify subscribed clients that a resource has been updated.
+   * @param {string} uri
+   * @returns {Promise<void>}
+   */
+  async function notifyResourceUpdated(uri) {
+    let hasAudience = false;
+    for (const set of subscribers.values()) {
+      if (set.has(uri)) {
+        hasAudience = true;
+        break;
+      }
+    }
+    if (hasAudience) {
+      await server.server.sendResourceUpdated({ uri });
+    }
+  }
+
+  return { notifyResourceUpdated };
+}

package/src/tools/add.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+
+/**
+ * Register the add tool returning structured totals.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @returns {ReturnType<import('@modelcontextprotocol/sdk/server/mcp.js').McpServer['registerTool']>}
+ */
+export function registerAdd(server) {
+  const inputSchema = {
+    first: z.number(),
+    second: z.number()
+  };
+
+  /**
+   * Sum two numbers to demonstrate structured responses.
+   * @param {{ first: number, second: number }} args
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function addTool(args) {
+    const total = args.first + args.second;
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Total: ${total}`
+        }
+      ],
+      structuredContent: { total }
+    };
+  }
+
+  return server.registerTool(
+    'add',
+    {
+      title: 'Add',
+      description: 'Combine two numbers and return the sum.',
+      inputSchema,
+      outputSchema: {
+        total: z.number()
+      }
+    },
+    addTool
+  );
+}

package/src/tools/annotated.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+
+/**
+ * Register a tool that exercises annotations and _meta without output schema.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @returns {ReturnType<import('@modelcontextprotocol/sdk/server/mcp.js').McpServer['registerTool']>}
+ */
+export function registerAnnotated(server) {
+  const inputSchema = {
+    label: z.string().min(1, 'Label is required')
+  };
+
+  /**
+   * Return a plain text response for annotation coverage.
+   * @param {{ label: string }} args
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function annotatedTool(args) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Annotated tool saw ${args.label}.`
+        }
+      ]
+    };
+  }
+
+  return server.registerTool(
+    'annotated',
+    {
+      description: 'Tool used to exercise annotation/title fallback and _meta extraction.',
+      inputSchema,
+      annotations: {
+        title: 'Annotated Tool',
+        readOnlyHint: true
+      },
+      _meta: {
+        owner: 'mcp-layer-schema'
+      }
+    },
+    annotatedTool
+  );
+}

package/src/tools/batch.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+
+/**
+ * Register a tool that accepts array/object inputs.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @returns {ReturnType<import('@modelcontextprotocol/sdk/server/mcp.js').McpServer['registerTool']>}
+ */
+export function registerBatch(server) {
+  const inputSchema = {
+    items: z.array(z.string()).min(1, 'Provide at least one item'),
+    meta: z.object({ tag: z.string().min(1, 'Tag is required') })
+  };
+
+  /**
+   * Summarize array/object inputs.
+   * @param {{ items: string[], meta: { tag: string } }} args
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function batchTool(args) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Batch ${args.meta.tag} contains ${args.items.length} items.`
+        }
+      ],
+      structuredContent: {
+        count: args.items.length,
+        tag: args.meta.tag
+      }
+    };
+  }
+
+  return server.registerTool(
+    'batch',
+    {
+      title: 'Batch',
+      description: 'Accepts array and object inputs for CLI parsing tests.',
+      inputSchema
+    },
+    batchTool
+  );
+}

package/src/tools/booking.js

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+
+/**
+ * Register the booking tool that triggers elicitation workflows.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @param {{ hasCapability: (capability: 'elicitation') => boolean }} capabilities
+ */
+export function registerBooking(server, capabilities) {
+  const inputSchema = {
+    restaurant: z.string().min(1),
+    date: z.string().min(1),
+    guests: z.number().int().min(1).max(12)
+  };
+
+  /**
+   * Demonstrate elicitation by asking for alternate booking dates.
+   * @param {{ restaurant: string, date: string, guests: number }} args
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function bookingTool(args) {
+    const baseMessage = `No tables available at ${args.restaurant} on ${args.date}.`;
+    if (!capabilities.hasCapability('elicitation')) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `${baseMessage} Client did not declare elicitation capability.`
+          }
+        ],
+        structuredContent: {
+          confirmed: false,
+          alternateDate: null,
+          message: `${baseMessage} Client lacks elicitation support.`
+        }
+      };
+    }
+
+    try {
+      const result = await server.server.elicitInput({
+        message: `${baseMessage} Provide an alternate date to continue.`,
+        requestedSchema: {
+          type: 'object',
+          properties: {
+            confirmAlternate: {
+              type: 'boolean',
+              title: 'Confirm alternate date',
+              description: 'Confirm whether we should book an alternate date.'
+            },
+            alternateDate: {
+              type: 'string',
+              title: 'Preferred alternate date',
+              description: 'ISO-8601 date string for the alternate booking.'
+            }
+          },
+          required: ['confirmAlternate']
+        }
+      });
+
+      const confirmed = result.action === 'accept' && Boolean(result.content?.confirmAlternate);
+      const alternate = confirmed ? result.content?.alternateDate ?? args.date : null;
+      const message = confirmed ? `Reservation confirmed for ${alternate ?? args.date}.` : `${baseMessage} Request declined.`;
+      return {
+        content: [
+          {
+            type: 'text',
+            text: message
+          }
+        ],
+        structuredContent: {
+          confirmed,
+          alternateDate: alternate,
+          message
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        content: [
+          {
+            type: 'text',
+            text: message
+          }
+        ],
+        structuredContent: {
+          confirmed: false,
+          alternateDate: null,
+          message
+        }
+      };
+    }
+  }
+
+  server.registerTool(
+    'booking',
+    {
+      title: 'Booking',
+      description: 'Trigger elicitation/create to confirm alternate dates.',
+      inputSchema,
+      outputSchema: {
+        confirmed: z.boolean(),
+        alternateDate: z.string().nullable(),
+        message: z.string()
+      }
+    },
+    bookingTool
+  );
+}

package/src/tools/dashboard.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+
+const uri = 'ui://dashboard/app.html';
+const csp = "default-src 'self'";
+const permissions = ['clipboard-read'];
+
+/**
+ * Register a tool that declares an MCP App UI resource.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @returns {ReturnType<import('@modelcontextprotocol/sdk/server/mcp.js').McpServer['registerTool']>}
+ */
+export function registerDashboard(server) {
+  const inputSchema = {
+    name: z.string().min(1, 'Name is required')
+  };
+
+  /**
+   * Return a simple payload while the host renders the UI resource.
+   * @param {{ name: string }} args
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function dashboardTool(args) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Dashboard ready for ${args.name}.`
+        }
+      ],
+      structuredContent: {
+        name: args.name,
+        resourceUri: uri
+      }
+    };
+  }
+
+  return server.registerTool(
+    'dashboard',
+    {
+      title: 'Dashboard',
+      description: 'Return a dashboard with an MCP App UI resource.',
+      inputSchema,
+      _meta: {
+        ui: {
+          resourceUri: uri,
+          csp,
+          permissions
+        }
+      }
+    },
+    dashboardTool
+  );
+}

package/src/tools/echo.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+
+/**
+ * Register the echo tool that optionally uppercases responses.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @returns {ReturnType<import('@modelcontextprotocol/sdk/server/mcp.js').McpServer['registerTool']>}
+ */
+export function registerEcho(server) {
+  const inputSchema = {
+    text: z.string().min(1, 'Text must be provided'),
+    loud: z.boolean().default(false)
+  };
+
+  /**
+   * Repeat supplied text and optionally uppercase the response.
+   * @param {{ text: string, loud: boolean }} args
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function echoTool(args) {
+    const text = args.loud ? args.text.toUpperCase() : args.text;
+    return {
+      content: [
+        {
+          type: 'text',
+          text
+        }
+      ],
+      structuredContent: { text, loud: args.loud }
+    };
+  }
+
+  return server.registerTool(
+    'echo',
+    {
+      title: 'Echo',
+      description: 'Repeat supplied text; uppercase when loud is true.',
+      inputSchema,
+      outputSchema: {
+        text: z.string(),
+        loud: z.boolean()
+      }
+    },
+    echoTool
+  );
+}

package/src/tools/files.js

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+
+/**
+ * Register the files tool that emits ResourceLinks referencing shared assets.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @param {{ references: Array<{ uri: string, name: string, description: string, mimeType: string }> }} context
+ */
+export function registerFiles(server, context) {
+  const inputSchema = {
+    filter: z.string().min(1).default('*'),
+    limit: z.number().int().min(1).max(context.references.length).default(context.references.length)
+  };
+
+  /**
+   * Emit ResourceLinks referencing manual and note resources.
+   * @param {{ filter: string, limit: number }} args
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function filesTool(args) {
+    const term = args.filter === '*' ? '' : args.filter.toLowerCase();
+    const matches = context.references
+      .filter(function filterReferences(entry) {
+        return entry.name.toLowerCase().includes(term);
+      })
+      .slice(0, args.limit);
+
+    const payload = {
+      count: matches.length,
+      files: matches.map(function mapMatches(entry) {
+        return {
+          uri: entry.uri,
+          name: entry.name,
+          description: entry.description,
+          mimeType: entry.mimeType
+        };
+      })
+    };
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Found ${payload.count} references.`
+        },
+        ...matches.map(function linkReferences(entry) {
+          return {
+            type: 'resource_link',
+            uri: entry.uri,
+            name: entry.name,
+            description: entry.description,
+            mimeType: entry.mimeType
+          };
+        })
+      ],
+      structuredContent: payload
+    };
+  }
+
+  server.registerTool(
+    'files',
+    {
+      title: 'Files',
+      description: 'List ResourceLinks for manual and note resources.',
+      inputSchema,
+      outputSchema: {
+        count: z.number().int(),
+        files: z.array(
+          z.object({
+            uri: z.string(),
+            name: z.string(),
+            description: z.string(),
+            mimeType: z.string()
+          })
+        )
+      }
+    },
+    filesTool
+  );
+}

package/src/tools/index.js

@@ -0,0 +1,37 @@
+import { registerAdd } from './add.js';
+import { registerAnnotated } from './annotated.js';
+import { registerBatch } from './batch.js';
+import { registerBooking } from './booking.js';
+import { registerDashboard } from './dashboard.js';
+import { registerEcho } from './echo.js';
+import { registerFiles } from './files.js';
+import { registerLogs } from './logs.js';
+import { registerNoteUpdate } from './note-update.js';
+import { registerProgress } from './progress.js';
+import { registerPresent } from './present.js';
+import { registerRebalance } from './rebalance.js';
+import { registerRoots } from './roots.js';
+import { registerSummaries } from './summaries.js';
+
+/**
+ * Register all server tools.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @param {{ references: Array<{ uri: string, name: string, description: string, mimeType: string }> }} context
+ * @param {{ hasCapability: (capability: 'sampling' | 'elicitation' | 'roots') => boolean }} capabilities
+ */
+export function registerTools(server, context, capabilities, notifier) {
+  const echoHandle = registerEcho(server);
+  const addHandle = registerAdd(server);
+  registerBatch(server);
+  registerAnnotated(server);
+  registerDashboard(server);
+  registerFiles(server, context);
+  registerSummaries(server, capabilities);
+  registerBooking(server, capabilities);
+  registerRoots(server, capabilities);
+  registerNoteUpdate(server, context, notifier);
+  registerLogs(server);
+  registerPresent(server);
+  registerProgress(server);
+  registerRebalance(server, { echo: echoHandle, add: addHandle });
+}

package/src/tools/logs.js

@@ -0,0 +1,56 @@
+import { LoggingLevelSchema } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+const levels = LoggingLevelSchema.options;
+
+/**
+ * Register the logs tool that emits notifications/message entries.
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ */
+export function registerLogs(server) {
+  const inputSchema = {
+    level: z.enum(levels),
+    message: z.string().min(1),
+    logger: z.string().default('diagnostics')
+  };
+
+  /**
+   * Emit a logging notification honoring the client's configured level filter.
+   * @param {{ level: typeof levels[number], message: string, logger: string }} args
+   * @returns {Promise<import('@modelcontextprotocol/sdk/types.js').CallToolResult>}
+   */
+  async function logsTool(args) {
+    await server.sendLoggingMessage({
+      level: args.level,
+      logger: args.logger,
+      data: args.message
+    });
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Logged ${args.level} message.`
+        }
+      ],
+      structuredContent: {
+        level: args.level,
+        logger: args.logger
+      }
+    };
+  }
+
+  server.registerTool(
+    'logs',
+    {
+      title: 'Logs',
+      description: 'Send notifications/message payloads at the requested level.',
+      inputSchema,
+      outputSchema: {
+        level: z.enum(levels),
+        logger: z.string()
+      }
+    },
+    logsTool
+  );
+}