fastmcp 1.6.1 → 1.8.0

package/src/FastMCP.ts

@@ -2,6 +2,7 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
   CallToolRequestSchema,
+  ClientCapabilities,
   ErrorCode,
   GetPromptRequestSchema,
   ListPromptsRequestSchema,
@@ -9,14 +10,28 @@ import {
   ListToolsRequestSchema,
   McpError,
   ReadResourceRequestSchema,
+  Root,
   ServerCapabilities,
   SetLevelRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { z } from "zod";
+import { setTimeout as delay } from "timers/promises";
 import { readFile } from "fs/promises";
 import { fileTypeFromBuffer } from "file-type";
-import { startSSEServer, type SSEServer } from "mcp-proxy";
+import { StrictEventEmitter } from "strict-event-emitter-types";
+import { EventEmitter } from "events";
+import { startSSEServer } from "mcp-proxy";
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+
+export type SSEServer = {
+  close: () => Promise<void>;
+};
+
+type FastMCPEvents = {
+  connect: (event: { session: FastMCPSession }) => void;
+  disconnect: (event: { session: FastMCPSession }) => void;
+};
 
 /**
  * Generates an image content object from a URL, file path, or buffer.
@@ -223,65 +238,131 @@ type LoggingLevel =
   | "alert"
   | "emergency";
 
-export class FastMCP {
-  #tools: Tool[];
-  #resources: Resource[];
-  #prompts: Prompt[];
-  #server: Server | null = null;
-  #options: ServerOptions;
+export class FastMCPSession {
+  #capabilities: ServerCapabilities = {};
   #loggingLevel: LoggingLevel = "info";
+  #server: Server;
+  #clientCapabilities?: ClientCapabilities;
+  #roots: Root[] = [];
+
+  constructor({
+    name,
+    version,
+    tools,
+    resources,
+    prompts,
+  }: {
+    name: string;
+    version: string;
+    tools: Tool[];
+    resources: Resource[];
+    prompts: Prompt[];
+  }) {
+    if (tools.length) {
+      this.#capabilities.tools = {};
+    }
 
-  constructor(public options: ServerOptions) {
-    this.#options = options;
-    this.#tools = [];
-    this.#resources = [];
-    this.#prompts = [];
+    if (resources.length) {
+      this.#capabilities.resources = {};
+    }
+
+    if (prompts.length) {
+      this.#capabilities.prompts = {};
+    }
+
+    this.#capabilities.logging = {};
+
+    this.#server = new Server(
+      { name: name, version: version },
+      { capabilities: this.#capabilities },
+    );
+
+    this.setupErrorHandling();
+    this.setupLoggingHandlers();
+
+    if (tools.length) {
+      this.setupToolHandlers(tools);
+    }
+
+    if (resources.length) {
+      this.setupResourceHandlers(resources);
+    }
+
+    if (prompts.length) {
+      this.setupPromptHandlers(prompts);
+    }
   }
 
-  private setupHandlers(server: Server) {
-    this.setupErrorHandling(server);
+  public get clientCapabilities(): ClientCapabilities | null {
+    return this.#clientCapabilities ?? null;
+  }
+
+  public get server(): Server {
+    return this.#server;
+  }
+
+  public async connect(transport: Transport) {
+    if (this.#server.transport) {
+      throw new UnexpectedStateError("Server is already connected");
+    }
+
+    await this.#server.connect(transport);
+
+    let attempt = 0;
+
+    while (attempt++ < 10) {
+      const capabilities = await this.#server.getClientCapabilities();
 
-    if (this.#tools.length) {
-      this.setupToolHandlers(server);
+      if (capabilities) {
+        this.#clientCapabilities = capabilities;
+
+        break;
+      }
+
+      await delay(100);
     }
 
-    if (this.#resources.length) {
-      this.setupResourceHandlers(server);
+    if (this.#clientCapabilities?.roots) {
+      const roots = await this.#server.listRoots();
+
+      this.#roots = roots.roots;
     }
 
-    if (this.#prompts.length) {
-      this.setupPromptHandlers(server);
+    if (!this.#clientCapabilities) {
+      throw new UnexpectedStateError("Server did not connect");
     }
+  }
 
-    server.setRequestHandler(SetLevelRequestSchema, (request) => {
-      this.#loggingLevel = request.params.level;
+  public get roots(): Root[] {
+    return this.#roots;
+  }
 
-      return {};
-    });
+  public async close() {
+    await this.#server.close();
   }
 
-  private setupErrorHandling(server: Server) {
-    server.onerror = (error) => {
+  private setupErrorHandling() {
+    this.#server.onerror = (error) => {
       console.error("[MCP Error]", error);
     };
-
-    process.on("SIGINT", async () => {
-      await server.close();
-      process.exit(0);
-    });
   }
 
-  /**
-   * Returns the current logging level.
-   */
   public get loggingLevel(): LoggingLevel {
     return this.#loggingLevel;
   }
 
-  private setupToolHandlers(server: Server) {
-    server.setRequestHandler(ListToolsRequestSchema, async () => {
+  private setupLoggingHandlers() {
+    this.#server.setRequestHandler(SetLevelRequestSchema, (request) => {
+      this.#loggingLevel = request.params.level;
+
+      return {};
+    });
+  }
+
+  private setupToolHandlers(tools: Tool[]) {
+    this.#server.setRequestHandler(ListToolsRequestSchema, async () => {
       return {
-        tools: this.#tools.map((tool) => {
+        tools: tools.map((tool) => {
           return {
             name: tool.name,
             description: tool.description,
@@ -293,10 +374,8 @@ export class FastMCP {
       };
     });
 
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const tool = this.#tools.find(
-        (tool) => tool.name === request.params.name,
-      );
+    this.#server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const tool = tools.find((tool) => tool.name === request.params.name);
 
       if (!tool) {
         throw new McpError(
@@ -326,7 +405,7 @@ export class FastMCP {
 
       try {
         const reportProgress = async (progress: Progress) => {
-          await server.notification({
+          await this.#server.notification({
             method: "notifications/progress",
             params: {
               ...progress,
@@ -337,7 +416,7 @@ export class FastMCP {
 
         const log = {
           debug: (message: string, context?: SerializableValue) => {
-            server.sendLoggingMessage({
+            this.#server.sendLoggingMessage({
               level: "debug",
               data: {
                 message,
@@ -346,7 +425,7 @@ export class FastMCP {
             });
           },
           error: (message: string, context?: SerializableValue) => {
-            server.sendLoggingMessage({
+            this.#server.sendLoggingMessage({
               level: "error",
               data: {
                 message,
@@ -355,7 +434,7 @@ export class FastMCP {
             });
           },
           info: (message: string, context?: SerializableValue) => {
-            server.sendLoggingMessage({
+            this.#server.sendLoggingMessage({
               level: "info",
               data: {
                 message,
@@ -364,7 +443,7 @@ export class FastMCP {
             });
           },
           warn: (message: string, context?: SerializableValue) => {
-            server.sendLoggingMessage({
+            this.#server.sendLoggingMessage({
               level: "warning",
               data: {
                 message,
@@ -408,10 +487,10 @@ export class FastMCP {
     });
   }
 
-  private setupResourceHandlers(server: Server) {
-    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  private setupResourceHandlers(resources: Resource[]) {
+    this.#server.setRequestHandler(ListResourcesRequestSchema, async () => {
       return {
-        resources: this.#resources.map((resource) => {
+        resources: resources.map((resource) => {
           return {
             uri: resource.uri,
             name: resource.name,
@@ -421,48 +500,51 @@ export class FastMCP {
       };
     });
 
-    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-      const resource = this.#resources.find(
-        (resource) => resource.uri === request.params.uri,
-      );
-
-      if (!resource) {
-        throw new McpError(
-          ErrorCode.MethodNotFound,
-          `Unknown resource: ${request.params.uri}`,
+    this.#server.setRequestHandler(
+      ReadResourceRequestSchema,
+      async (request) => {
+        const resource = resources.find(
+          (resource) => resource.uri === request.params.uri,
         );
-      }
 
-      let result: Awaited<ReturnType<Resource["load"]>>;
+        if (!resource) {
+          throw new McpError(
+            ErrorCode.MethodNotFound,
+            `Unknown resource: ${request.params.uri}`,
+          );
+        }
 
-      try {
-        result = await resource.load();
-      } catch (error) {
-        throw new McpError(
-          ErrorCode.InternalError,
-          `Error reading resource: ${error}`,
-          {
-            uri: resource.uri,
-          },
-        );
-      }
+        let result: Awaited<ReturnType<Resource["load"]>>;
 
-      return {
-        contents: [
-          {
-            uri: resource.uri,
-            mimeType: resource.mimeType,
-            ...result,
-          },
-        ],
-      };
-    });
+        try {
+          result = await resource.load();
+        } catch (error) {
+          throw new McpError(
+            ErrorCode.InternalError,
+            `Error reading resource: ${error}`,
+            {
+              uri: resource.uri,
+            },
+          );
+        }
+
+        return {
+          contents: [
+            {
+              uri: resource.uri,
+              mimeType: resource.mimeType,
+              ...result,
+            },
+          ],
+        };
+      },
+    );
   }
 
-  private setupPromptHandlers(server: Server) {
-    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+  private setupPromptHandlers(prompts: Prompt[]) {
+    this.#server.setRequestHandler(ListPromptsRequestSchema, async () => {
       return {
-        prompts: this.#prompts.map((prompt) => {
+        prompts: prompts.map((prompt) => {
           return {
             name: prompt.name,
             description: prompt.description,
@@ -472,8 +554,8 @@ export class FastMCP {
       };
     });
 
-    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-      const prompt = this.#prompts.find(
+    this.#server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+      const prompt = prompts.find(
         (prompt) => prompt.name === request.params.name,
       );
 
@@ -519,6 +601,31 @@ export class FastMCP {
       };
     });
   }
+}
+
+const FastMCPEventEmitterBase: {
+  new (): StrictEventEmitter<EventEmitter, FastMCPEvents>;
+} = EventEmitter;
+
+class FastMCPEventEmitter extends FastMCPEventEmitterBase {}
+
+export class FastMCP extends FastMCPEventEmitter {
+  #options: ServerOptions;
+  #prompts: Prompt[] = [];
+  #resources: Resource[] = [];
+  #sessions: FastMCPSession[] = [];
+  #sseServer: SSEServer | null = null;
+  #tools: Tool[] = [];
+
+  constructor(public options: ServerOptions) {
+    super();
+
+    this.#options = options;
+  }
+
+  public get sessions(): FastMCPSession[] {
+    return this.#sessions;
+  }
 
   /**
    * Adds a tool to the server.
@@ -541,8 +648,6 @@ export class FastMCP {
     this.#prompts.push(prompt);
   }
 
-  #sseServer: SSEServer | null = null;
-
   /**
    * Starts the server.
    */
@@ -556,41 +661,56 @@ export class FastMCP {
       transportType: "stdio",
     },
   ) {
-    const capabilities: ServerCapabilities = {};
-
-    if (this.#tools.length) {
-      capabilities.tools = {};
-    }
-
-    if (this.#resources.length) {
-      capabilities.resources = {};
-    }
-
-    if (this.#prompts.length) {
-      capabilities.prompts = {};
-    }
-
-    capabilities.logging = {};
+    if (options.transportType === "stdio") {
+      const transport = new StdioServerTransport();
 
-    this.#server = new Server(
-      { name: this.#options.name, version: this.#options.version },
-      { capabilities },
-    );
+      const session = new FastMCPSession({
+        name: this.#options.name,
+        version: this.#options.version,
+        tools: this.#tools,
+        resources: this.#resources,
+        prompts: this.#prompts,
+      });
 
-    this.setupHandlers(this.#server);
+      await session.connect(transport);
 
-    if (options.transportType === "stdio") {
-      const transport = new StdioServerTransport();
+      this.#sessions.push(session);
 
-      await this.#server.connect(transport);
+      this.emit("connect", {
+        session,
+      });
 
       console.error(`server is running on stdio`);
     } else if (options.transportType === "sse") {
-      this.#sseServer = await startSSEServer({
+      this.#sseServer = await startSSEServer<FastMCPSession>({
         endpoint: options.sse.endpoint as `/${string}`,
         port: options.sse.port,
-        server: this.#server,
+        createServer: async () => {
+          return new FastMCPSession({
+            name: this.#options.name,
+            version: this.#options.version,
+            tools: this.#tools,
+            resources: this.#resources,
+            prompts: this.#prompts,
+          });
+        },
+        onClose: (session) => {
+          this.emit("disconnect", {
+            session,
+          });
+        },
+        onConnect: async (session) => {
+          this.#sessions.push(session);
+
+          this.emit("connect", {
+            session,
+          });
+        },
       });
+
+      console.error(
+        `server is running on SSE at http://localhost:${options.sse.port}${options.sse.endpoint}`,
+      );
     } else {
       throw new Error("Invalid transport type");
     }

package/src/examples/addition.ts

@@ -21,6 +21,32 @@ server.addTool({
   },
 });
 
+server.addResource({
+  uri: "file:///logs/app.log",
+  name: "Application Logs",
+  mimeType: "text/plain",
+  async load() {
+    return {
+      text: "Example log content",
+    };
+  },
+});
+
+server.addPrompt({
+  name: "git-commit",
+  description: "Generate a Git commit message",
+  arguments: [
+    {
+      name: "changes",
+      description: "Git diff or description of changes",
+      required: true,
+    },
+  ],
+  load: async (args) => {
+    return `Generate a concise but descriptive commit message for these changes:\n\n${args.changes}`;
+  },
+});
+
 server.start({
   transportType: "stdio",
 });

package/vitest.config.js

@@ -0,0 +1,9 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    poolOptions: {
+      forks: { execArgv: ["--experimental-eventsource"] },
+    },
+  },
+});