fastmcp 4.23.7 → 4.23.9

package/dist/{chunk-7WNI6AGD.js → chunk-75ZLE5AS.js}

@@ -1,10 +1,11 @@
 import {
   cancelResponseBody
-} from "./chunk-CA2EPNZF.js";
+} from "./chunk-G44SPVP7.js";
 import {
+  objectRootSchema,
   strictInputSchema,
   zodInputSchema
-} from "./chunk-YZ5QEHBX.js";
+} from "./chunk-OKKFL2M4.js";
 
 // src/FastMCP.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -186,9 +187,18 @@ function jsonSchemaAdapter(schema) {
   };
 }
 async function compileSchema(schema) {
+  const dialect = schema.$schema?.replace(/^http:\/\//, "https://").replace(/#$/, "");
+  const isDraft2020 = dialect === "https://json-schema.org/draft/2020-12/schema";
+  const isDraft2019 = dialect === "https://json-schema.org/draft/2019-09/schema";
   let ajvModule;
   try {
-    ajvModule = await import("ajv");
+    if (isDraft2020) {
+      ajvModule = await import("ajv/dist/2020.js");
+    } else if (isDraft2019) {
+      ajvModule = await import("ajv/dist/2019.js");
+    } else {
+      ajvModule = await import("ajv");
+    }
   } catch {
     throw new Error(
       'The "ajv" package is required to validate JSON Schema tool parameters. Install it with: npm install ajv'
@@ -204,7 +214,9 @@ async function compileSchema(schema) {
     addFormats(ajv);
   } catch {
   }
-  return ajv.compile(schema);
+  return ajv.compile(
+    isDraft2020 || isDraft2019 ? { ...schema, $schema: dialect } : schema
+  );
 }
 function toIssue(error) {
   const path = error.instancePath.split("/").slice(1).map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~")).map((segment) => {
@@ -487,6 +499,28 @@ var ServerState = /* @__PURE__ */ ((ServerState2) => {
 })(ServerState || {});
 var FastMCPSessionEventEmitter = class extends FastMCPSessionEventEmitterBase {
 };
+var lazyRequestBody = (req) => {
+  let iterator;
+  return new ReadableStream(
+    {
+      async cancel(reason) {
+        await iterator?.return?.(reason);
+      },
+      async pull(controller) {
+        iterator ??= req[Symbol.asyncIterator]();
+        const { done, value } = await iterator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(
+          typeof value === "string" ? Buffer.from(value) : new Uint8Array(value)
+        );
+      }
+    },
+    { highWaterMark: 0 }
+  );
+};
 var FastMCPSession = class extends FastMCPSessionEventEmitter {
   get clientCapabilities() {
     return this.#clientCapabilities ?? null;
@@ -933,7 +967,11 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
   }
   #formatSchemaIssues(issues) {
     return this.#utils?.formatInvalidParamsErrorMessage ? this.#utils.formatInvalidParamsErrorMessage(issues) : issues.map((issue) => {
-      const path = issue.path?.join(".") || "root";
+      const path = issue.path?.map(
+        (segment) => String(
+          typeof segment === "object" && segment !== null ? segment.key : segment
+        )
+      ).join(".") || "root";
       return `${path}: ${issue.message}`;
     }).join(", ");
   }
@@ -1103,7 +1141,7 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
    */
   #startStreamKeepalive(extra, toolName) {
     const config = this.#streamKeepaliveConfig;
-    if (!config?.enabled) {
+    if (!config?.enabled || extra.signal?.aborted) {
       return () => {
       };
     }
@@ -1124,7 +1162,10 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
       });
     }, intervalMs);
     timer.unref?.();
-    const stop = () => clearInterval(timer);
+    const stop = () => {
+      clearInterval(timer);
+      extra.signal?.removeEventListener("abort", stop);
+    };
     extra.signal?.addEventListener("abort", stop, { once: true });
     return stop;
   }
@@ -1571,8 +1612,8 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
             },
             name: tool.name,
             ...tool.outputSchema && {
-              outputSchema: await toJsonSchema(
-                tool.outputSchema
+              outputSchema: objectRootSchema(
+                await toJsonSchema(tool.outputSchema)
               )
             },
             // Pass through _meta for MCP ext-apps UI support (issue #229)
@@ -1610,13 +1651,33 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
         }
         const progressToken = request.params?._meta?.progressToken;
         let result;
+        const timeoutAbort = new AbortController();
+        const signal = AbortSignal.any([
+          timeoutAbort.signal,
+          this.#abortController.signal,
+          // Only ever aborted for an explicit `notifications/cancelled`; the
+          // session signal above is what covers a client that simply left.
+          ...extra.signal ? [extra.signal] : []
+        ]);
+        const sendNotification = async (notification) => {
+          if (signal.aborted) {
+            return;
+          }
+          try {
+            await extra.sendNotification(notification);
+          } catch (error) {
+            if (!signal.aborted) {
+              throw error;
+            }
+          }
+        };
         try {
           const reportProgress = async (progress) => {
             if (progressToken === void 0) {
               return;
             }
             try {
-              await extra.sendNotification({
+              await sendNotification({
                 method: "notifications/progress",
                 params: {
                   ...progress,
@@ -1633,11 +1694,11 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
               );
             }
           };
-          const log = this.#createLog(extra.sendNotification);
+          const log = this.#createLog(sendNotification);
           const streamContent = async (content) => {
             const contentArray = Array.isArray(content) ? content : [content];
             try {
-              await extra.sendNotification({
+              await sendNotification({
                 method: "notifications/tool/streamContent",
                 params: {
                   content: contentArray,
@@ -1660,14 +1721,6 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
               toolName: request.params.name
             });
           }
-          const timeoutAbort = new AbortController();
-          const signal = AbortSignal.any([
-            timeoutAbort.signal,
-            this.#abortController.signal,
-            // Only ever aborted for an explicit `notifications/cancelled`; the
-            // session signal above is what covers a client that simply left.
-            ...extra.signal ? [extra.signal] : []
-          ]);
           const executeToolPromise = Promise.resolve(
             tool.execute(args, {
               client: {
@@ -1684,25 +1737,37 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
             })
           );
           const stopStreamKeepalive = this.#startStreamKeepalive(
-            extra,
+            { sendNotification, signal },
             request.params.name
           );
-          const maybeStringResult = await (tool.timeoutMs ? Promise.race([
-            executeToolPromise,
-            new Promise((_, reject) => {
-              const timeoutId = setTimeout(() => {
-                const timedOut = new UserError(
+          let timeoutId;
+          let stopWaitingForAbort = () => {
+          };
+          const aborted = new Promise((_, reject) => {
+            const onAbort = () => reject(signal.reason);
+            stopWaitingForAbort = () => signal.removeEventListener("abort", onAbort);
+            signal.addEventListener("abort", onAbort, { once: true });
+            if (signal.aborted) {
+              onAbort();
+            }
+          });
+          if (tool.timeoutMs && !signal.aborted) {
+            timeoutId = setTimeout(() => {
+              timeoutAbort.abort(
+                new UserError(
                   `Tool '${request.params.name}' timed out after ${tool.timeoutMs}ms. Consider increasing timeoutMs or optimizing the tool implementation.`
-                );
-                timeoutAbort.abort(timedOut);
-                reject(timedOut);
-              }, tool.timeoutMs);
-              executeToolPromise.then(
-                () => clearTimeout(timeoutId),
-                () => clearTimeout(timeoutId)
+                )
               );
-            })
-          ]) : executeToolPromise).finally(stopStreamKeepalive);
+            }, tool.timeoutMs);
+          }
+          const maybeStringResult = await Promise.race([
+            executeToolPromise,
+            aborted
+          ]).finally(() => {
+            clearTimeout(timeoutId);
+            stopWaitingForAbort();
+            stopStreamKeepalive();
+          });
           await delay(1);
           if (maybeStringResult === void 0 || maybeStringResult === null) {
             result = ContentResultZodSchema.parse({
@@ -1743,12 +1808,29 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
           } else {
             result = ContentResultZodSchema.parse(maybeStringResult);
           }
+          if (tool.outputSchema && result.structuredContent === void 0 && !result.isError) {
+            throw new UserError(
+              `Tool '${request.params.name}' returned no structured content. Please return a value that matches the tool's outputSchema.`
+            );
+          }
         } catch (error) {
           if (error instanceof UserError) {
+            let structuredContent = error.extras;
+            if (structuredContent && tool.outputSchema) {
+              try {
+                structuredContent = await this.#validateStructuredContent(
+                  tool,
+                  structuredContent,
+                  request.params.name
+                );
+              } catch {
+                structuredContent = void 0;
+              }
+            }
             return {
               content: [{ text: error.message, type: "text" }],
               isError: true,
-              ...error.extras ? { structuredContent: error.extras } : {}
+              ...structuredContent ? { structuredContent } : {}
             };
           }
           const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1964,7 +2046,9 @@ var FastMCP = class extends FastMCPEventEmitter {
    * Adds a resource to the server.
    */
   addResource(resource) {
-    this.#resources = this.#resources.filter((r) => r.name !== resource.name);
+    this.#resources = this.#resources.filter(
+      (r) => r.name !== resource.name && r.uri !== resource.uri
+    );
     this.#resources.push(resource);
     if (this.#serverState === "running" /* Running */) {
       this.#resourcesListChanged(this.#resources);
@@ -1974,13 +2058,12 @@ var FastMCP = class extends FastMCPEventEmitter {
    * Adds resources to the server.
    */
   addResources(resources) {
-    const newResourceNames = new Set(
-      resources.map((resource) => resource.name)
-    );
-    this.#resources = this.#resources.filter(
-      (r) => !newResourceNames.has(r.name)
-    );
-    this.#resources.push(...resources);
+    for (const resource of resources) {
+      this.#resources = this.#resources.filter(
+        (r) => r.name !== resource.name && r.uri !== resource.uri
+      );
+      this.#resources.push(resource);
+    }
     if (this.#serverState === "running" /* Running */) {
       this.#resourcesListChanged(this.#resources);
     }
@@ -2001,13 +2084,12 @@ var FastMCP = class extends FastMCPEventEmitter {
    * Adds resource templates to the server.
    */
   addResourceTemplates(resources) {
-    const newResourceTemplateNames = new Set(
-      resources.map((resource) => resource.name)
-    );
-    this.#resourcesTemplates = this.#resourcesTemplates.filter(
-      (t) => !newResourceTemplateNames.has(t.name)
-    );
-    this.#resourcesTemplates.push(...resources);
+    for (const resource of resources) {
+      this.#resourcesTemplates = this.#resourcesTemplates.filter(
+        (template) => template.name !== resource.name
+      );
+      this.#resourcesTemplates.push(resource);
+    }
     if (this.#serverState === "running" /* Running */) {
       this.#resourceTemplatesListChanged(this.#resourcesTemplates);
     }
@@ -2028,9 +2110,12 @@ var FastMCP = class extends FastMCPEventEmitter {
    */
   addTools(tools) {
     tools.forEach(assertToolSchemas);
-    const newToolNames = new Set(tools.map((tool) => tool.name));
-    this.#tools = this.#tools.filter((t) => !newToolNames.has(t.name));
-    this.#tools.push(...tools);
+    const toolsByName = new Map(this.#tools.map((tool) => [tool.name, tool]));
+    for (const tool of tools) {
+      toolsByName.delete(tool.name);
+      toolsByName.set(tool.name, tool);
+    }
+    this.#tools = Array.from(toolsByName.values());
     if (this.#serverState === "running" /* Running */) {
       this.#toolsListChanged(this.#tools);
     }
@@ -2261,6 +2346,13 @@ var FastMCP = class extends FastMCPEventEmitter {
   async start(options) {
     const config = this.#parseRuntimeConfig(options);
     if (config.transportType === "stdio") {
+      const logger = this.#options.logger ?? {
+        debug: (...args) => console.error(...args),
+        error: (...args) => console.error(...args),
+        info: (...args) => console.error(...args),
+        log: (...args) => console.error(...args),
+        warn: (...args) => console.warn(...args)
+      };
       const transport = new StdioServerTransport();
       let auth;
       const authRequired = this.#authenticate !== void 0;
@@ -2287,7 +2379,7 @@ var FastMCP = class extends FastMCPEventEmitter {
         hasTools: this.#tools.length > 0,
         icons: this.#options.icons,
         instructions: this.#options.instructions,
-        logger: this.#logger,
+        logger,
         name: this.#options.name,
         onToolCall: this.#options.onToolCall,
         ping: this.#options.ping,
@@ -2332,6 +2424,9 @@ var FastMCP = class extends FastMCPEventEmitter {
         this.#serverState = "running" /* Running */;
       }
     } else if (config.transportType === "httpStream") {
+      if (this.#httpStreamServer) {
+        throw new Error("HTTP server is already running");
+      }
       const httpConfig = config.httpStream;
       const protocol = httpConfig.sslCert || httpConfig.sslKey ? "https" : "http";
       const streamEndpoint = joinPaths(
@@ -2461,6 +2556,7 @@ var FastMCP = class extends FastMCPEventEmitter {
     );
     if (this.#httpStreamServer) {
       await this.#httpStreamServer.close();
+      this.#httpStreamServer = null;
     }
     this.#serverState = "stopped" /* Stopped */;
   }
@@ -3067,9 +3163,7 @@ var FastMCP = class extends FastMCPEventEmitter {
     const hasBody = method !== "GET" && method !== "HEAD";
     if (hasBody) {
       return new Request(url.toString(), {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        body: req,
-        // Node.js IncomingMessage is readable stream
+        body: lazyRequestBody(req),
         duplex: "half",
         // Required for streaming bodies
         headers,
@@ -3247,4 +3341,4 @@ export {
   FastMCPSession,
   FastMCP
 };
-//# sourceMappingURL=chunk-7WNI6AGD.js.map
+//# sourceMappingURL=chunk-75ZLE5AS.js.map