feat: basic tool checkin

Author: zcaceres

README.md

@@ -27,10 +27,27 @@ mcp.serve();
 
 ### Resources
 
+The handler registered for a given path will be called with the parameters from the path.
+
+If you need to access underlying resources like files or databases, you can use the `resource` method.
+
 ```typescript
-mcp.resource("protocol://path-to-resource", params, async (context) => {
-  return "Hello, world!";
+mcp.resource("file://:fileName/:id", async ({ fileName, id }, ctx) => {
+  return {
+    contents: [
+      {
+        uri: "whatever",
+        type: "text",
+        text: `File: ${fileName} with ID: ${id}`,
+      },
+    ],
+  };
 });
+```
+
+### Tools
+
+
 
 ```
 

lib/EasyMCP.ts

@@ -2,7 +2,10 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import type {
   MCPResourceRequestParams,
   ResourceOptions,
+  ResourceRequestFn,
   ServerOptions,
+  ToolOptions,
+  ToolRequestFn,
 } from "../types";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import ResourceManager, {
@@ -11,21 +14,26 @@ import ResourceManager, {
 } from "./ResourceManager";
 import {
   ListResourcesRequestSchema,
+  ListToolsRequestSchema,
   ReadResourceRequestSchema,
+  type ListToolsResult,
   type ReadResourceRequest,
   type ReadResourceResult,
 } from "@modelcontextprotocol/sdk/types.js";
+import ToolManager from "./ToolManager";
 
 class EasyMCP {
   name: string;
   opts: ServerOptions;
   resourceManager: ResourceManager;
+  toolManager: ToolManager;
   server: Server;
 
   private constructor(name: string, opts: ServerOptions) {
     this.name = name;
     this.opts = opts;
     this.resourceManager = ResourceManager.create();
+    this.toolManager = ToolManager.create();
     this.server = new Server(
       {
         name: this.name,
@@ -58,11 +66,11 @@ class EasyMCP {
     }
   }
 
-  resource(
-    uri: string,
-    fn: (params: MCPResourceRequestParams) => Promise<any>,
-    opts: ResourceOptions = {},
-  ) {
+  tool(fn: ToolRequestFn, name: string, opts: ToolOptions) {
+    return this.toolManager.add(name, fn, opts);
+  }
+
+  resource(uri: string, fn: ResourceRequestFn, opts: ResourceOptions = {}) {
     return this.resourceManager.add(
       {
         uri,
@@ -99,6 +107,14 @@ class EasyMCP {
       },
     );
     console.log("Registered ReadResource endpoint");
+
+    // Tools
+    this.server.setRequestHandler(
+      ListToolsRequestSchema,
+      async (): Promise<ListToolsResult> => {
+        return { tools: this.toolManager.list() };
+      },
+    );
   }
 
   static create(name: string, opts: ServerOptions) {

lib/ToolManager.test.ts

@@ -0,0 +1,90 @@
+import { test, expect, beforeEach, describe } from "bun:test";
+import ToolManager, { ToolNotFoundError, ToolConverter } from "./ToolManager";
+import type { EasyMCPTool } from "../types";
+import { createMockTool } from "./mocks";
+
+describe("ToolManager", () => {
+  let toolManager: ToolManager;
+
+  beforeEach(() => {
+    toolManager = ToolManager.create();
+  });
+
+  test("create() should return a new instance of ToolManager", () => {
+    expect(toolManager).toBeInstanceOf(ToolManager);
+  });
+
+  test("add() should add a tool with a function", async () => {
+    const mockTool = createMockTool();
+    const mockFn = async () => ({ result: "Mock result" });
+    toolManager.add(mockTool.name, mockFn, mockTool);
+    const result = await toolManager.get(mockTool.name);
+    expect(result).toEqual(expect.objectContaining(mockTool));
+  });
+
+  test("get() should return the added tool", async () => {
+    const mockTool1 = createMockTool();
+    const mockTool2 = createMockTool();
+    const mockFn1 = async () => ({ result: "Result 1" });
+    const mockFn2 = async () => ({ result: "Result 2" });
+
+    toolManager.add(mockTool1.name, mockFn1, mockTool1);
+    toolManager.add(mockTool2.name, mockFn2, mockTool2);
+
+    const result1 = await toolManager.get(mockTool1.name);
+    const result2 = await toolManager.get(mockTool2.name);
+    expect(result1).toEqual(expect.objectContaining(mockTool1));
+    expect(result2).toEqual(expect.objectContaining(mockTool2));
+  });
+
+  test("get() should throw ToolNotFoundError for non-existent tool", async () => {
+    expect(toolManager.get("non-existent-tool")).rejects.toThrow(
+      ToolNotFoundError,
+    );
+  });
+
+  test("list() should return all added tools", () => {
+    const mockTools = [createMockTool(), createMockTool(), createMockTool()];
+
+    mockTools.forEach((tool) =>
+      toolManager.add(tool.name, async () => ({}), tool),
+    );
+
+    const listedTools = toolManager.list();
+    expect(listedTools).toHaveLength(mockTools.length);
+    expect(listedTools).toEqual(
+      expect.arrayContaining(
+        mockTools.map((tool) => expect.objectContaining(tool)),
+      ),
+    );
+  });
+
+  test("list() should return an empty array when no tools are added", () => {
+    expect(toolManager.list()).toEqual([]);
+  });
+});
+
+describe("ToolConverter", () => {
+  test("fromMCPTool should convert EasyMCPTool to Tool", () => {
+    const mockTool = createMockTool();
+    const easyMCPTool: EasyMCPTool = {
+      ...mockTool,
+      fn: async () => ({}),
+    };
+
+    const result = ToolConverter.fromMCPTool(easyMCPTool);
+    expect(result).toEqual(mockTool);
+    expect(result).not.toHaveProperty("fn");
+  });
+
+  test("toMCPTool should convert Tool to EasyMCPTool", () => {
+    const mockTool = createMockTool();
+    const mockFn = async () => ({});
+
+    const result = ToolConverter.toMCPTool(mockTool, mockFn);
+    expect(result).toEqual({
+      ...mockTool,
+      fn: mockFn,
+    });
+  });
+});

lib/ToolManager.ts

@@ -0,0 +1,63 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { EasyMCPTool, ToolOptions, ToolRequestFn } from "../types";
+
+export class ToolError extends Error {}
+
+export class ToolNotFoundError extends ToolError {
+  message = "Tool not found";
+}
+
+export class ToolConverter {
+  static fromMCPTool(tool: EasyMCPTool): Tool {
+    return {
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+    };
+  }
+
+  static toMCPTool(tool: Tool, fn: ToolRequestFn): EasyMCPTool {
+    return {
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      fn,
+    };
+  }
+}
+
+export default class ToolManager {
+  private tools: Record<string, EasyMCPTool>;
+  private constructor() {
+    this.tools = {};
+  }
+
+  add(name: string, fn: ToolRequestFn, opts: ToolOptions) {
+    this.tools[name] = ToolConverter.toMCPTool(
+      {
+        name,
+        inputSchema: opts.inputSchema ?? {},
+        description: opts.description,
+      },
+      fn,
+    );
+  }
+
+  list() {
+    return Object.values(this.tools).map(ToolConverter.fromMCPTool);
+  }
+
+  async get(name: string) {
+    const foundTool = this.tools[name];
+
+    if (!foundTool) {
+      throw new ToolNotFoundError();
+    }
+
+    return foundTool;
+  }
+
+  static create() {
+    return new ToolManager();
+  }
+}

lib/mocks.ts

@@ -0,0 +1,27 @@
+import { faker } from "@faker-js/faker";
+import type { Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
+
+export function createMockResource(): Resource {
+  return {
+    uri: faker.internet.url(),
+    name: faker.lorem.word(),
+    description: faker.lorem.sentence(),
+    mimeType: faker.system.mimeType(),
+  };
+}
+
+export function createMockTool(): Tool {
+  return {
+    name: faker.lorem.word(),
+    description: faker.lorem.sentence(),
+    inputSchema: {
+      type: "object",
+      properties: {
+        [faker.lorem.word()]: {
+          type: faker.helpers.arrayElement(["string", "number", "boolean"]),
+        },
+      },
+      required: [faker.lorem.word()],
+    },
+  };
+}

package.json

@@ -3,7 +3,8 @@
   "module": "index.ts",
   "type": "module",
   "scripts": {
-    "start": "bun run index.ts"
+    "start": "bun run index.ts",
+    "dev": "bun --watch index.ts"
   },
   "devDependencies": {
     "@anatine/zod-mock": "^3.13.4",

types.d.ts

@@ -1,11 +1,11 @@
-import type { Resource } from "@modelcontextprotocol/sdk/types.js";
+import type { Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
 
 export type ServerOptions = {
   version: `${number}.${number}.${number}`;
 };
 
 export type EasyMCPResource = Resource & {
-  fn: Function;
+  fn: ResourceRequestFn;
 };
 
 export type MCPResourceRequestParams = Record<string, string>;
@@ -15,3 +15,21 @@ export type ResourceOptions = Partial<{
   description: string;
   mimeType: string;
 }>;
+
+export type ResourceRequestFn = (
+  params: MCPResourceRequestParams,
+  context: ResourceRequestContext,
+) => Promise<any>;
+
+export type ResourceRequestContext = {
+  uri: string;
+  getResource: (uri: string) => Promise<any>;
+};
+
+export type ToolRequestFn = (params: any) => Promise<any>;
+
+export type ToolOptions = Pick<Tool, "inputSchema" | "description">;
+
+export type EasyMCPTool = Tool & {
+  fn: ToolRequestFn;
+};