feat: add mcp server implementation with tool handling capabilities

Author: ribeirogab

src/definitions/index.ts

@@ -0,0 +1,2 @@
+export * from './mcp-transport-type';
+export * from './mcp-tool';

src/definitions/mcp-tool.ts

@@ -0,0 +1,11 @@
+import { z, ZodObject, type ZodRawShape } from 'zod';
+
+export type McpToolExecute<Args extends ZodRawShape> = (
+  request: z.infer<ZodObject<Args>>,
+) => Promise<{ content: { type: string; text: string }[] }>;
+
+export type McpTool<Args extends ZodRawShape = ZodRawShape> = {
+  execute: McpToolExecute<Args>;
+  parameters: Args;
+  name: string;
+};

src/definitions/mcp-transport-type.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const MCP_TRANSPORT_TYPE_SCHEMA = z.literal('stdio');
+
+export type McpTransportType = z.infer<typeof MCP_TRANSPORT_TYPE_SCHEMA>;

src/index.ts

@@ -0,0 +1,2 @@
+export * from './definitions';
+export * from './mcp-server';

src/mcp-server.ts

@@ -0,0 +1,76 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { z, type ZodRawShape } from 'zod';
+import zodToJsonSchema from 'zod-to-json-schema';
+
+import {
+  MCP_TRANSPORT_TYPE_SCHEMA,
+  type McpTool,
+  McpToolExecute,
+} from './definitions';
+
+export class McpServer {
+  private readonly server: Server;
+  private readonly tools: McpTool<ZodRawShape>[] = [];
+
+  constructor({ name, version }: { name: string; version?: string }) {
+    this.server = new Server(
+      { name, version: version ?? '1.0.0' },
+      {
+        capabilities: {
+          tools: {},
+        },
+      },
+    );
+  }
+
+  public tool<Args extends ZodRawShape>({
+    parameters,
+    execute,
+    name,
+  }: McpTool<Args>) {
+    this.tools.push({
+      execute: execute as McpToolExecute<ZodRawShape>,
+      parameters,
+      name,
+    });
+  }
+
+  public async start(dto: { transportType: string }) {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: this.tools.map((tool) => ({
+          inputSchema: zodToJsonSchema(z.object(tool.parameters)),
+          name: tool.name,
+        })),
+      };
+    });
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      for (const tool of this.tools) {
+        if (tool.name === request.params.name) {
+          return await tool.execute(request.params.arguments as ZodRawShape);
+        }
+      }
+
+      throw new Error('Tool not found');
+    });
+
+    const transportType = MCP_TRANSPORT_TYPE_SCHEMA.parse(dto.transportType);
+
+    if (transportType === 'stdio') {
+      return this.startStdio();
+    }
+
+    throw new Error(`Unknown transport type: ${transportType}`);
+  }
+
+  private async startStdio() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+  }
+}