fastmcp 1.22.4 → 1.23.1

package/dist/FastMCP.js

@@ -15,18 +15,16 @@ import {
   RootsListChangedNotificationSchema,
   SetLevelRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import { toJsonSchema } from "xsschema";
-import { z } from "zod";
-import { setTimeout as delay } from "timers/promises";
-import { readFile } from "fs/promises";
-import { fileTypeFromBuffer } from "file-type";
 import { EventEmitter } from "events";
+import { fileTypeFromBuffer } from "file-type";
+import { readFile } from "fs/promises";
 import Fuse from "fuse.js";
 import { startSSEServer } from "mcp-proxy";
+import { setTimeout as delay } from "timers/promises";
+import { fetch } from "undici";
 import parseURITemplate from "uri-templates";
-import {
-  fetch
-} from "undici";
+import { toJsonSchema } from "xsschema";
+import { z } from "zod";
 var imageContent = async (input) => {
   let rawData;
   if ("url" in input) {
@@ -47,9 +45,9 @@ var imageContent = async (input) => {
   const mimeType = await fileTypeFromBuffer(rawData);
   const base64Data = rawData.toString("base64");
   return {
-    type: "image",
     data: base64Data,
-    mimeType: mimeType?.mime ?? "image/png"
+    mimeType: mimeType?.mime ?? "image/png",
+    type: "image"
   };
 };
 var audioContent = async (input) => {
@@ -65,14 +63,16 @@ var audioContent = async (input) => {
   } else if ("buffer" in input) {
     rawData = input.buffer;
   } else {
-    throw new Error("Invalid input: Provide a valid 'url', 'path', or 'buffer'");
+    throw new Error(
+      "Invalid input: Provide a valid 'url', 'path', or 'buffer'"
+    );
   }
   const mimeType = await fileTypeFromBuffer(rawData);
   const base64Data = rawData.toString("base64");
   return {
-    type: "audio",
     data: base64Data,
-    mimeType: mimeType?.mime ?? "audio/mpeg"
+    mimeType: mimeType?.mime ?? "audio/mpeg",
+    type: "audio"
   };
 };
 var FastMCPError = class extends Error {
@@ -92,14 +92,13 @@ var UnexpectedStateError = class extends FastMCPError {
 var UserError = class extends UnexpectedStateError {
 };
 var TextContentZodSchema = z.object({
-  type: z.literal("text"),
   /**
    * The text content of the message.
    */
-  text: z.string()
+  text: z.string(),
+  type: z.literal("text")
 }).strict();
 var ImageContentZodSchema = z.object({
-  type: z.literal("image"),
   /**
    * The base64-encoded image data.
    */
@@ -107,7 +106,8 @@ var ImageContentZodSchema = z.object({
   /**
    * The MIME type of the image. Different providers may support different image types.
    */
-  mimeType: z.string()
+  mimeType: z.string(),
+  type: z.literal("image")
 }).strict();
 var ContentZodSchema = z.discriminatedUnion("type", [
   TextContentZodSchema,
@@ -119,39 +119,53 @@ var ContentResultZodSchema = z.object({
 }).strict();
 var CompletionZodSchema = z.object({
   /**
-   * An array of completion values. Must not exceed 100 items.
+   * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
    */
-  values: z.array(z.string()).max(100),
+  hasMore: z.optional(z.boolean()),
   /**
    * The total number of completion options available. This can exceed the number of values actually sent in the response.
    */
   total: z.optional(z.number().int()),
   /**
-   * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
+   * An array of completion values. Must not exceed 100 items.
    */
-  hasMore: z.optional(z.boolean())
+  values: z.array(z.string()).max(100)
 });
 var FastMCPSessionEventEmitterBase = EventEmitter;
 var FastMCPSessionEventEmitter = class extends FastMCPSessionEventEmitterBase {
 };
 var FastMCPSession = class extends FastMCPSessionEventEmitter {
+  get clientCapabilities() {
+    return this.#clientCapabilities ?? null;
+  }
+  get loggingLevel() {
+    return this.#loggingLevel;
+  }
+  get roots() {
+    return this.#roots;
+  }
+  get server() {
+    return this.#server;
+  }
+  #auth;
   #capabilities = {};
   #clientCapabilities;
   #loggingLevel = "info";
+  #pingInterval = null;
   #prompts = [];
   #resources = [];
   #resourceTemplates = [];
   #roots = [];
   #server;
-  #auth;
   constructor({
     auth,
+    instructions,
     name,
-    version,
-    tools,
+    prompts,
     resources,
     resourcesTemplates,
-    prompts
+    tools,
+    version
   }) {
     super();
     this.#auth = auth;
@@ -170,7 +184,7 @@ var FastMCPSession = class extends FastMCPSessionEventEmitter {
     this.#capabilities.logging = {};
     this.#server = new Server(
       { name, version },
-      { capabilities: this.#capabilities }
+      { capabilities: this.#capabilities, instructions }
     );
     this.setupErrorHandling();
     this.setupLoggingHandlers();
@@ -195,72 +209,15 @@ var FastMCPSession = class extends FastMCPSessionEventEmitter {
       this.setupPromptHandlers(prompts);
     }
   }
-  addResource(inputResource) {
-    this.#resources.push(inputResource);
-  }
-  addResourceTemplate(inputResourceTemplate) {
-    const completers = {};
-    for (const argument of inputResourceTemplate.arguments ?? []) {
-      if (argument.complete) {
-        completers[argument.name] = argument.complete;
-      }
+  async close() {
+    if (this.#pingInterval) {
+      clearInterval(this.#pingInterval);
     }
-    const resourceTemplate = {
-      ...inputResourceTemplate,
-      complete: async (name, value) => {
-        if (completers[name]) {
-          return await completers[name](value);
-        }
-        return {
-          values: []
-        };
-      }
-    };
-    this.#resourceTemplates.push(resourceTemplate);
-  }
-  addPrompt(inputPrompt) {
-    const completers = {};
-    const enums = {};
-    for (const argument of inputPrompt.arguments ?? []) {
-      if (argument.complete) {
-        completers[argument.name] = argument.complete;
-      }
-      if (argument.enum) {
-        enums[argument.name] = argument.enum;
-      }
+    try {
+      await this.#server.close();
+    } catch (error) {
+      console.error("[FastMCP error]", "could not close server", error);
     }
-    const prompt = {
-      ...inputPrompt,
-      complete: async (name, value) => {
-        if (completers[name]) {
-          return await completers[name](value);
-        }
-        if (enums[name]) {
-          const fuse = new Fuse(enums[name], {
-            keys: ["value"]
-          });
-          const result = fuse.search(value);
-          return {
-            values: result.map((item) => item.item),
-            total: result.length
-          };
-        }
-        return {
-          values: []
-        };
-      }
-    };
-    this.#prompts.push(prompt);
-  }
-  get clientCapabilities() {
-    return this.#clientCapabilities ?? null;
-  }
-  get server() {
-    return this.#server;
-  }
-  #pingInterval = null;
-  async requestSampling(message) {
-    return this.#server.createMessage(message);
   }
   async connect(transport) {
     if (this.#server.transport) {
@@ -284,9 +241,11 @@ var FastMCPSession = class extends FastMCPSessionEventEmitter {
         const roots = await this.#server.listRoots();
         this.#roots = roots.roots;
       } catch (e) {
-        console.error(`[FastMCP error] received error listing roots.
+        console.error(
+          `[FastMCP error] received error listing roots.
 
-${e instanceof Error ? e.stack : JSON.stringify(e)}`);
+${e instanceof Error ? e.stack : JSON.stringify(e)}`
+        );
       }
     }
     if (this.#clientCapabilities) {
@@ -299,26 +258,65 @@ ${e instanceof Error ? e.stack : JSON.stringify(e)}`);
       }, 1e3);
     }
   }
-  get roots() {
-    return this.#roots;
+  async requestSampling(message) {
+    return this.#server.createMessage(message);
   }
-  async close() {
-    if (this.#pingInterval) {
-      clearInterval(this.#pingInterval);
-    }
-    try {
-      await this.#server.close();
-    } catch (error) {
-      console.error("[FastMCP error]", "could not close server", error);
+  addPrompt(inputPrompt) {
+    const completers = {};
+    const enums = {};
+    for (const argument of inputPrompt.arguments ?? []) {
+      if (argument.complete) {
+        completers[argument.name] = argument.complete;
+      }
+      if (argument.enum) {
+        enums[argument.name] = argument.enum;
+      }
     }
-  }
-  setupErrorHandling() {
-    this.#server.onerror = (error) => {
-      console.error("[FastMCP error]", error);
+    const prompt = {
+      ...inputPrompt,
+      complete: async (name, value) => {
+        if (completers[name]) {
+          return await completers[name](value);
+        }
+        if (enums[name]) {
+          const fuse = new Fuse(enums[name], {
+            keys: ["value"]
+          });
+          const result = fuse.search(value);
+          return {
+            total: result.length,
+            values: result.map((item) => item.item)
+          };
+        }
+        return {
+          values: []
+        };
+      }
     };
+    this.#prompts.push(prompt);
   }
-  get loggingLevel() {
-    return this.#loggingLevel;
+  addResource(inputResource) {
+    this.#resources.push(inputResource);
+  }
+  addResourceTemplate(inputResourceTemplate) {
+    const completers = {};
+    for (const argument of inputResourceTemplate.arguments ?? []) {
+      if (argument.complete) {
+        completers[argument.name] = argument.complete;
+      }
+    }
+    const resourceTemplate = {
+      ...inputResourceTemplate,
+      complete: async (name, value) => {
+        if (completers[name]) {
+          return await completers[name](value);
+        }
+        return {
+          values: []
+        };
+      }
+    };
+    this.#resourceTemplates.push(resourceTemplate);
   }
   setupCompleteHandlers() {
     this.#server.setRequestHandler(CompleteRequestSchema, async (request) => {
@@ -381,18 +379,10 @@ ${e instanceof Error ? e.stack : JSON.stringify(e)}`);
       });
     });
   }
-  setupRootsHandlers() {
-    this.#server.setNotificationHandler(
-      RootsListChangedNotificationSchema,
-      () => {
-        this.#server.listRoots().then((roots) => {
-          this.#roots = roots.roots;
-          this.emit("rootsChanged", {
-            roots: roots.roots
-          });
-        });
-      }
-    );
+  setupErrorHandling() {
+    this.#server.onerror = (error) => {
+      console.error("[FastMCP error]", error);
+    };
   }
   setupLoggingHandlers() {
     this.#server.setRequestHandler(SetLevelRequestSchema, (request) => {
@@ -400,118 +390,56 @@ ${e instanceof Error ? e.stack : JSON.stringify(e)}`);
       return {};
     });
   }
-  setupToolHandlers(tools) {
-    this.#server.setRequestHandler(ListToolsRequestSchema, async () => {
+  setupPromptHandlers(prompts) {
+    this.#server.setRequestHandler(ListPromptsRequestSchema, async () => {
       return {
-        tools: await Promise.all(tools.map(async (tool) => {
+        prompts: prompts.map((prompt) => {
           return {
-            name: tool.name,
-            description: tool.description,
-            inputSchema: tool.parameters ? await toJsonSchema(tool.parameters) : void 0
+            arguments: prompt.arguments,
+            complete: prompt.complete,
+            description: prompt.description,
+            name: prompt.name
           };
-        }))
+        })
       };
     });
-    this.#server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const tool = tools.find((tool2) => tool2.name === request.params.name);
-      if (!tool) {
+    this.#server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+      const prompt = prompts.find(
+        (prompt2) => prompt2.name === request.params.name
+      );
+      if (!prompt) {
         throw new McpError(
           ErrorCode.MethodNotFound,
-          `Unknown tool: ${request.params.name}`
+          `Unknown prompt: ${request.params.name}`
         );
       }
-      let args = void 0;
-      if (tool.parameters) {
-        const parsed = await tool.parameters["~standard"].validate(
-          request.params.arguments
-        );
-        if (parsed.issues) {
+      const args = request.params.arguments;
+      for (const arg of prompt.arguments ?? []) {
+        if (arg.required && !(args && arg.name in args)) {
           throw new McpError(
-            ErrorCode.InvalidParams,
-            `Invalid ${request.params.name} parameters`
+            ErrorCode.InvalidRequest,
+            `Missing required argument: ${arg.name}`
           );
         }
-        args = parsed.value;
       }
-      const progressToken = request.params?._meta?.progressToken;
       let result;
       try {
-        const reportProgress = async (progress) => {
-          await this.#server.notification({
-            method: "notifications/progress",
-            params: {
-              ...progress,
-              progressToken
-            }
-          });
-        };
-        const log = {
-          debug: (message, context) => {
-            this.#server.sendLoggingMessage({
-              level: "debug",
-              data: {
-                message,
-                context
-              }
-            });
-          },
-          error: (message, context) => {
-            this.#server.sendLoggingMessage({
-              level: "error",
-              data: {
-                message,
-                context
-              }
-            });
-          },
-          info: (message, context) => {
-            this.#server.sendLoggingMessage({
-              level: "info",
-              data: {
-                message,
-                context
-              }
-            });
-          },
-          warn: (message, context) => {
-            this.#server.sendLoggingMessage({
-              level: "warning",
-              data: {
-                message,
-                context
-              }
-            });
-          }
-        };
-        const maybeStringResult = await tool.execute(args, {
-          reportProgress,
-          log,
-          session: this.#auth
-        });
-        if (typeof maybeStringResult === "string") {
-          result = ContentResultZodSchema.parse({
-            content: [{ type: "text", text: maybeStringResult }]
-          });
-        } else if ("type" in maybeStringResult) {
-          result = ContentResultZodSchema.parse({
-            content: [maybeStringResult]
-          });
-        } else {
-          result = ContentResultZodSchema.parse(maybeStringResult);
-        }
+        result = await prompt.load(args);
       } catch (error) {
-        if (error instanceof UserError) {
-          return {
-            content: [{ type: "text", text: error.message }],
-            isError: true
-          };
-        }
-        return {
-          content: [{ type: "text", text: `Error: ${error}` }],
-          isError: true
-        };
+        throw new McpError(
+          ErrorCode.InternalError,
+          `Error loading prompt: ${error}`
+        );
       }
-      return result;
+      return {
+        description: prompt.description,
+        messages: [
+          {
+            content: { text: result, type: "text" },
+            role: "user"
+          }
+        ]
+      };
     });
   }
   setupResourceHandlers(resources) {
@@ -519,9 +447,9 @@ ${e instanceof Error ? e.stack : JSON.stringify(e)}`);
       return {
         resources: resources.map((resource) => {
           return {
-            uri: resource.uri,
+            mimeType: resource.mimeType,
             name: resource.name,
-            mimeType: resource.mimeType
+            uri: resource.uri
           };
         })
       };
@@ -547,9 +475,9 @@ ${e instanceof Error ? e.stack : JSON.stringify(e)}`);
               return {
                 contents: [
                   {
-                    uri,
                     mimeType: resourceTemplate.mimeType,
                     name: resourceTemplate.name,
+                    uri,
                     ...result
                   }
                 ]
@@ -578,9 +506,9 @@ ${e instanceof Error ? e.stack : JSON.stringify(e)}`);
           if (Array.isArray(maybeArrayResult)) {
             return {
               contents: maybeArrayResult.map((result) => ({
-                uri: resource.uri,
                 mimeType: resource.mimeType,
                 name: resource.name,
+                uri: resource.uri,
                 ...result
               }))
             };
@@ -588,9 +516,9 @@ ${e instanceof Error ? e.stack : JSON.stringify(e)}`);
             return {
               contents: [
                 {
-                  uri: resource.uri,
                   mimeType: resource.mimeType,
                   name: resource.name,
+                  uri: resource.uri,
                   ...maybeArrayResult
                 }
               ]
@@ -618,56 +546,134 @@ ${e instanceof Error ? e.stack : JSON.stringify(e)}`);
       }
     );
   }
-  setupPromptHandlers(prompts) {
-    this.#server.setRequestHandler(ListPromptsRequestSchema, async () => {
+  setupRootsHandlers() {
+    this.#server.setNotificationHandler(
+      RootsListChangedNotificationSchema,
+      () => {
+        this.#server.listRoots().then((roots) => {
+          this.#roots = roots.roots;
+          this.emit("rootsChanged", {
+            roots: roots.roots
+          });
+        });
+      }
+    );
+  }
+  setupToolHandlers(tools) {
+    this.#server.setRequestHandler(ListToolsRequestSchema, async () => {
       return {
-        prompts: prompts.map((prompt) => {
-          return {
-            name: prompt.name,
-            description: prompt.description,
-            arguments: prompt.arguments,
-            complete: prompt.complete
-          };
-        })
+        tools: await Promise.all(
+          tools.map(async (tool) => {
+            return {
+              annotations: tool.annotations,
+              description: tool.description,
+              inputSchema: tool.parameters ? await toJsonSchema(tool.parameters) : void 0,
+              name: tool.name
+            };
+          })
+        )
       };
     });
-    this.#server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-      const prompt = prompts.find(
-        (prompt2) => prompt2.name === request.params.name
-      );
-      if (!prompt) {
+    this.#server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const tool = tools.find((tool2) => tool2.name === request.params.name);
+      if (!tool) {
         throw new McpError(
           ErrorCode.MethodNotFound,
-          `Unknown prompt: ${request.params.name}`
+          `Unknown tool: ${request.params.name}`
         );
       }
-      const args = request.params.arguments;
-      for (const arg of prompt.arguments ?? []) {
-        if (arg.required && !(args && arg.name in args)) {
+      let args = void 0;
+      if (tool.parameters) {
+        const parsed = await tool.parameters["~standard"].validate(
+          request.params.arguments
+        );
+        if (parsed.issues) {
           throw new McpError(
-            ErrorCode.InvalidRequest,
-            `Missing required argument: ${arg.name}`
+            ErrorCode.InvalidParams,
+            `Invalid ${request.params.name} parameters`
           );
         }
+        args = parsed.value;
       }
+      const progressToken = request.params?._meta?.progressToken;
       let result;
       try {
-        result = await prompt.load(args);
+        const reportProgress = async (progress) => {
+          await this.#server.notification({
+            method: "notifications/progress",
+            params: {
+              ...progress,
+              progressToken
+            }
+          });
+        };
+        const log = {
+          debug: (message, context) => {
+            this.#server.sendLoggingMessage({
+              data: {
+                context,
+                message
+              },
+              level: "debug"
+            });
+          },
+          error: (message, context) => {
+            this.#server.sendLoggingMessage({
+              data: {
+                context,
+                message
+              },
+              level: "error"
+            });
+          },
+          info: (message, context) => {
+            this.#server.sendLoggingMessage({
+              data: {
+                context,
+                message
+              },
+              level: "info"
+            });
+          },
+          warn: (message, context) => {
+            this.#server.sendLoggingMessage({
+              data: {
+                context,
+                message
+              },
+              level: "warning"
+            });
+          }
+        };
+        const maybeStringResult = await tool.execute(args, {
+          log,
+          reportProgress,
+          session: this.#auth
+        });
+        if (typeof maybeStringResult === "string") {
+          result = ContentResultZodSchema.parse({
+            content: [{ text: maybeStringResult, type: "text" }]
+          });
+        } else if ("type" in maybeStringResult) {
+          result = ContentResultZodSchema.parse({
+            content: [maybeStringResult]
+          });
+        } else {
+          result = ContentResultZodSchema.parse(maybeStringResult);
+        }
       } catch (error) {
-        throw new McpError(
-          ErrorCode.InternalError,
-          `Error loading prompt: ${error}`
-        );
+        if (error instanceof UserError) {
+          return {
+            content: [{ text: error.message, type: "text" }],
+            isError: true
+          };
+        }
+        return {
+          content: [{ text: `Error: ${error}`, type: "text" }],
+          isError: true
+        };
       }
-      return {
-        description: prompt.description,
-        messages: [
-          {
-            role: "user",
-            content: { type: "text", text: result }
-          }
-        ]
-      };
+      return result;
     });
   }
 };
@@ -681,6 +687,10 @@ var FastMCP = class extends FastMCPEventEmitter {
     this.#options = options;
     this.#authenticate = options.authenticate;
   }
+  get sessions() {
+    return this.#sessions;
+  }
+  #authenticate;
   #options;
   #prompts = [];
   #resources = [];
@@ -688,15 +698,11 @@ var FastMCP = class extends FastMCPEventEmitter {
   #sessions = [];
   #sseServer = null;
   #tools = [];
-  #authenticate;
-  get sessions() {
-    return this.#sessions;
-  }
   /**
-   * Adds a tool to the server.
+   * Adds a prompt to the server.
    */
-  addTool(tool) {
-    this.#tools.push(tool);
+  addPrompt(prompt) {
+    this.#prompts.push(prompt);
   }
   /**
    * Adds a resource to the server.
@@ -711,10 +717,10 @@ var FastMCP = class extends FastMCPEventEmitter {
     this.#resourcesTemplates.push(resource);
   }
   /**
-   * Adds a prompt to the server.
+   * Adds a tool to the server.
    */
-  addPrompt(prompt) {
-    this.#prompts.push(prompt);
+  addTool(tool) {
+    this.#tools.push(tool);
   }
   /**
    * Starts the server.
@@ -725,12 +731,13 @@ var FastMCP = class extends FastMCPEventEmitter {
     if (options.transportType === "stdio") {
       const transport = new StdioServerTransport();
       const session = new FastMCPSession({
+        instructions: this.#options.instructions,
         name: this.#options.name,
-        version: this.#options.version,
-        tools: this.#tools,
+        prompts: this.#prompts,
         resources: this.#resources,
         resourcesTemplates: this.#resourcesTemplates,
-        prompts: this.#prompts
+        tools: this.#tools,
+        version: this.#options.version
       });
       await session.connect(transport);
       this.#sessions.push(session);
@@ -739,8 +746,6 @@ var FastMCP = class extends FastMCPEventEmitter {
       });
     } else if (options.transportType === "sse") {
       this.#sseServer = await startSSEServer({
-        endpoint: options.sse.endpoint,
-        port: options.sse.port,
         createServer: async (request) => {
           let auth;
           if (this.#authenticate) {
@@ -749,13 +754,14 @@ var FastMCP = class extends FastMCPEventEmitter {
           return new FastMCPSession({
             auth,
             name: this.#options.name,
-            version: this.#options.version,
-            tools: this.#tools,
+            prompts: this.#prompts,
             resources: this.#resources,
             resourcesTemplates: this.#resourcesTemplates,
-            prompts: this.#prompts
+            tools: this.#tools,
+            version: this.#options.version
           });
         },
+        endpoint: options.sse.endpoint,
         onClose: (session) => {
           this.emit("disconnect", {
             session
@@ -766,7 +772,8 @@ var FastMCP = class extends FastMCPEventEmitter {
           this.emit("connect", {
             session
           });
-        }
+        },
+        port: options.sse.port
       });
       console.info(
         `[FastMCP info] server is running on SSE at http://localhost:${options.sse.port}${options.sse.endpoint}`