fastmcp 1.6.1 → 1.7.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "fastmcp",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "main": "dist/FastMCP.js",
   "scripts": {
     "build": "tsup",
-    "test": "vitest run && tsc",
+    "test": "vitest run && tsc && jsr publish --dry-run",
     "format": "prettier --write . && eslint --fix ."
   },
   "bin": {
@@ -24,7 +24,8 @@
     "@modelcontextprotocol/sdk": "^1.0.4",
     "execa": "^9.5.2",
     "file-type": "^19.6.0",
-    "mcp-proxy": "^1.3.0",
+    "mcp-proxy": "^2.0.2",
+    "strict-event-emitter-types": "^2.0.0",
     "yargs": "^17.7.2",
     "zod": "^3.24.1",
     "zod-to-json-schema": "^3.24.1"
@@ -51,8 +52,8 @@
     "@types/yargs": "^17.0.33",
     "eslint": "^9.17.0",
     "eslint-plugin-perfectionist": "^4.4.0",
-    "eventsource": "^3.0.2",
     "get-port-please": "^3.1.2",
+    "jsr": "^0.13.2",
     "prettier": "^3.4.2",
     "semantic-release": "^24.2.0",
     "tsup": "^8.3.5",

package/src/FastMCP.test.ts

@@ -1,10 +1,9 @@
-import { FastMCP, UserError, imageContent } from "./FastMCP.js";
+import { FastMCP, FastMCPSession, UserError, imageContent } from "./FastMCP.js";
 import { z } from "zod";
 import { test, expect, vi } from "vitest";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { getRandomPort } from "get-port-please";
-import { EventSource } from "eventsource";
 import { setTimeout as delay } from "timers/promises";
 import {
   ErrorCode,
@@ -12,9 +11,6 @@ import {
   McpError,
 } from "@modelcontextprotocol/sdk/types.js";
 
-// @ts-expect-error - figure out how to use --experimental-eventsource with vitest
-global.EventSource = EventSource;
-
 const runWithTestServer = async ({
   run,
   start,
@@ -26,6 +22,7 @@ const runWithTestServer = async ({
   }: {
     client: Client;
     server: FastMCP;
+    session: FastMCPSession;
   }) => Promise<void>;
 }) => {
   const port = await getRandomPort();
@@ -55,9 +52,15 @@ const runWithTestServer = async ({
       new URL(`http://localhost:${port}/sse`),
     );
 
-    await client.connect(transport);
+    const session = await new Promise<FastMCPSession>((resolve) => {
+      server.on("connect", (event) => {
+        resolve(event.session);
+      });
+
+      client.connect(transport);
+    });
 
-    await run({ client, server });
+    await run({ client, server, session });
   } finally {
     await server.stop();
   }
@@ -369,21 +372,19 @@ test("tracks tool progress", async () => {
 test("sets logging levels", async () => {
   await runWithTestServer({
     start: async () => {
-      const server = new FastMCP({
+      return new FastMCP({
         name: "Test",
         version: "1.0.0",
       });
-
-      return server;
     },
-    run: async ({ client, server }) => {
+    run: async ({ client, session }) => {
       await client.setLoggingLevel("debug");
 
-      expect(server.loggingLevel).toBe("debug");
+      expect(session.loggingLevel).toBe("debug");
 
       await client.setLoggingLevel("info");
 
-      expect(server.loggingLevel).toBe("info");
+      expect(session.loggingLevel).toBe("info");
     },
   });
 });
@@ -543,3 +544,116 @@ test("adds prompts", async () => {
     },
   });
 });
+
+test("uses events to notify server of client connect/disconnect", async () => {
+  const port = await getRandomPort();
+
+  const server = new FastMCP({
+    name: "Test",
+    version: "1.0.0",
+  });
+
+  const onConnect = vi.fn();
+  const onDisconnect = vi.fn();
+
+  server.on("connect", onConnect);
+  server.on("disconnect", onDisconnect);
+
+  await server.start({
+    transportType: "sse",
+    sse: {
+      endpoint: "/sse",
+      port,
+    },
+  });
+
+  const client = new Client(
+    {
+      name: "example-client",
+      version: "1.0.0",
+    },
+    {
+      capabilities: {},
+    },
+  );
+
+  const transport = new SSEClientTransport(
+    new URL(`http://localhost:${port}/sse`),
+  );
+
+  await client.connect(transport);
+
+  await delay(100);
+
+  expect(onConnect).toHaveBeenCalledTimes(1);
+  expect(onDisconnect).toHaveBeenCalledTimes(0);
+
+  expect(server.sessions).toEqual([expect.any(FastMCPSession)]);
+
+  await client.close();
+
+  await delay(100);
+
+  expect(onConnect).toHaveBeenCalledTimes(1);
+  expect(onDisconnect).toHaveBeenCalledTimes(1);
+
+  await server.stop();
+});
+
+test("handles multiple clients", async () => {
+  const port = await getRandomPort();
+
+  const server = new FastMCP({
+    name: "Test",
+    version: "1.0.0",
+  });
+
+  await server.start({
+    transportType: "sse",
+    sse: {
+      endpoint: "/sse",
+      port,
+    },
+  });
+
+  const client1 = new Client(
+    {
+      name: "example-client",
+      version: "1.0.0",
+    },
+    {
+      capabilities: {},
+    },
+  );
+
+  const transport1 = new SSEClientTransport(
+    new URL(`http://localhost:${port}/sse`),
+  );
+
+  await client1.connect(transport1);
+
+  const client2 = new Client(
+    {
+      name: "example-client",
+      version: "1.0.0",
+    },
+    {
+      capabilities: {},
+    },
+  );
+
+  const transport2 = new SSEClientTransport(
+    new URL(`http://localhost:${port}/sse`),
+  );
+
+  await client2.connect(transport2);
+
+  await delay(100);
+
+  expect(server.sessions).toEqual([
+    expect.any(FastMCPSession),
+    expect.any(FastMCPSession),
+  ]);
+
+  await server.stop();
+});

package/src/FastMCP.ts

@@ -16,7 +16,19 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 import { z } from "zod";
 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 +235,89 @@ 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;
+
+  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 = {};
+    }
 
-  private setupHandlers(server: Server) {
-    this.setupErrorHandling(server);
+    this.#capabilities.logging = {};
+
+    this.#server = new Server(
+      { name: name, version: version },
+      { capabilities: this.#capabilities },
+    );
 
-    if (this.#tools.length) {
-      this.setupToolHandlers(server);
+    this.setupErrorHandling();
+    this.setupLoggingHandlers();
+
+    if (tools.length) {
+      this.setupToolHandlers(tools);
     }
 
-    if (this.#resources.length) {
-      this.setupResourceHandlers(server);
+    if (resources.length) {
+      this.setupResourceHandlers(resources);
     }
 
-    if (this.#prompts.length) {
-      this.setupPromptHandlers(server);
+    if (prompts.length) {
+      this.setupPromptHandlers(prompts);
     }
+  }
 
-    server.setRequestHandler(SetLevelRequestSchema, (request) => {
-      this.#loggingLevel = request.params.level;
+  public get server(): Server {
+    return this.#server;
+  }
 
-      return {};
-    });
+  public connect(transport: Transport) {
+    this.#server.connect(transport);
   }
 
-  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 +329,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 +360,7 @@ export class FastMCP {
 
       try {
         const reportProgress = async (progress: Progress) => {
-          await server.notification({
+          await this.#server.notification({
             method: "notifications/progress",
             params: {
               ...progress,
@@ -337,7 +371,7 @@ export class FastMCP {
 
         const log = {
           debug: (message: string, context?: SerializableValue) => {
-            server.sendLoggingMessage({
+            this.#server.sendLoggingMessage({
               level: "debug",
               data: {
                 message,
@@ -346,7 +380,7 @@ export class FastMCP {
             });
           },
           error: (message: string, context?: SerializableValue) => {
-            server.sendLoggingMessage({
+            this.#server.sendLoggingMessage({
               level: "error",
               data: {
                 message,
@@ -355,7 +389,7 @@ export class FastMCP {
             });
           },
           info: (message: string, context?: SerializableValue) => {
-            server.sendLoggingMessage({
+            this.#server.sendLoggingMessage({
               level: "info",
               data: {
                 message,
@@ -364,7 +398,7 @@ export class FastMCP {
             });
           },
           warn: (message: string, context?: SerializableValue) => {
-            server.sendLoggingMessage({
+            this.#server.sendLoggingMessage({
               level: "warning",
               data: {
                 message,
@@ -408,10 +442,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 +455,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 +509,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 +556,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 +603,6 @@ export class FastMCP {
     this.#prompts.push(prompt);
   }
 
-  #sseServer: SSEServer | null = null;
-
   /**
    * Starts the server.
    */
@@ -556,41 +616,81 @@ 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({
         endpoint: options.sse.endpoint as `/${string}`,
         port: options.sse.port,
-        server: this.#server,
+        createServer: async () => {
+          const session = new FastMCPSession({
+            name: this.#options.name,
+            version: this.#options.version,
+            tools: this.#tools,
+            resources: this.#resources,
+            prompts: this.#prompts,
+          });
+
+          this.#sessions.push(session);
+
+          return session.server;
+        },
+        onClose: (server) => {
+          const session = this.#sessions.find(
+            (session) => session.server === server,
+          );
+
+          if (!session) {
+            throw new UnexpectedStateError("Server not found");
+          }
+
+          this.#sessions = this.#sessions.filter(
+            (maybeOurSession) => maybeOurSession !== session,
+          );
+
+          this.emit("disconnect", {
+            session,
+          });
+        },
+        onConnect: async (server) => {
+          const session = this.#sessions.find(
+            (session) => session.server === server,
+          );
+
+          if (!session) {
+            throw new UnexpectedStateError("Server not found");
+          }
+
+          // TODO investigate where is the race condition
+          setTimeout(() => {
+            this.emit("connect", {
+              session,
+            });
+          }, 100);
+        },
       });
+
+      console.error(
+        `server is running on SSE at http://localhost:${options.sse.port}${options.sse.endpoint}`,
+      );
     } else {
       throw new Error("Invalid transport type");
     }