fastmcp 4.22.5 → 4.22.7

package/dist/{chunk-A6QGY7T7.js → chunk-NI4JFIL4.js}

@@ -1,6 +1,6 @@
 import {
   cancelResponseBody
-} from "./chunk-XPKMA7DH.js";
+} from "./chunk-ISYL7EKR.js";
 import {
   strictInputSchema
 } from "./chunk-UMDUIBFW.js";
@@ -684,77 +684,12 @@ var FastMCPSession = class extends FastMCPSessionEventEmitter {
       throw new UnexpectedStateError("Server is already connected");
     }
     this.#connectionState = "connecting";
+    const streamableHttp = !this.#stateless && isStreamableHttpTransport(transport);
     try {
       await this.#server.connect(transport);
-      if (!this.#stateless) {
-        let attempt = 0;
-        const maxAttempts = 10;
-        const retryDelay = 100;
-        while (attempt++ < maxAttempts) {
-          const capabilities = this.#server.getClientCapabilities();
-          if (capabilities) {
-            this.#clientCapabilities = capabilities;
-            break;
-          }
-          await delay(retryDelay);
-        }
-        if (!this.#clientCapabilities) {
-          this.#logger.warn(
-            `[FastMCP warning] could not infer client capabilities after ${maxAttempts} attempts. Connection may be unstable.`
-          );
-        }
-      }
-      if (this.#rootsConfig?.enabled !== false && this.#clientCapabilities?.roots?.listChanged && typeof this.#server.listRoots === "function") {
-        try {
-          const roots = await this.#server.listRoots();
-          this.#roots = roots?.roots || [];
-        } catch (e) {
-          if (e instanceof McpError && e.code === ErrorCode.MethodNotFound) {
-            this.#logger.debug(
-              "[FastMCP debug] listRoots method not supported by client"
-            );
-          } else {
-            this.#logger.error(
-              `[FastMCP error] received error listing roots.
-
-${e instanceof Error ? e.stack : JSON.stringify(e)}`
-            );
-          }
-        }
-      }
-      if (this.#clientCapabilities) {
-        const pingConfig = this.#getPingConfig();
-        if (pingConfig.enabled) {
-          this.#pingInterval = setInterval(async () => {
-            if (this.#pingInFlight) {
-              return;
-            }
-            this.#pingInFlight = true;
-            try {
-              await this.#server.ping();
-            } catch {
-              const logLevel = pingConfig.logLevel;
-              if (logLevel === "debug") {
-                this.#logger.debug("[FastMCP debug] server ping failed");
-              } else if (logLevel === "warning") {
-                this.#logger.warn(
-                  "[FastMCP warning] server is not responding to ping"
-                );
-              } else if (logLevel === "error") {
-                this.#logger.error(
-                  "[FastMCP error] server is not responding to ping"
-                );
-              } else {
-                this.#logger.info("[FastMCP info] server ping failed");
-              }
-            } finally {
-              this.#pingInFlight = false;
-            }
-          }, pingConfig.intervalMs);
-        }
+      if (!streamableHttp) {
+        await this.#setUpSession(false);
       }
-      this.#connectionState = "ready";
-      this.emit("ready");
     } catch (error) {
       this.#connectionState = "error";
       const errorEvent = {
@@ -763,6 +698,18 @@ ${e instanceof Error ? e.stack : JSON.stringify(e)}`
       this.emit("error", errorEvent);
       throw error;
     }
+    if (streamableHttp) {
+      this.#setUpSession(true).catch((error) => {
+        this.#connectionState = "error";
+        if (this.listenerCount("error") > 0) {
+          this.emit("error", {
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+        } else {
+          this.#logger.error("[FastMCP error] session setup failed", error);
+        }
+      });
+    }
   }
   promptsListChanged(prompts) {
     if (!this.#canRefresh("prompts")) {
@@ -967,6 +914,52 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
       logLevel: pingConfig.logLevel || "debug"
     };
   }
+  /**
+   * Fetches the client's roots if it advertised `roots.listChanged`.
+   *
+   * Over Streamable HTTP a server-initiated request travels on the client's
+   * standalone GET stream, which the client opens only after initialization,
+   * and the transport drops a request sent before that. So there each attempt
+   * is bounded and retried, and the result is announced with `rootsChanged`.
+   */
+  async #loadRoots(streamableHttp) {
+    if (this.#rootsConfig?.enabled === false || !this.#clientCapabilities?.roots?.listChanged || typeof this.#server.listRoots !== "function") {
+      return;
+    }
+    const maxAttempts = streamableHttp ? 5 : 1;
+    for (let attempt = 1; ; attempt++) {
+      try {
+        const roots = await this.#server.listRoots(
+          void 0,
+          streamableHttp ? { timeout: 1e3 } : void 0
+        );
+        this.#roots = roots?.roots || [];
+        if (streamableHttp) {
+          this.emit("rootsChanged", { roots: this.#roots });
+        }
+        return;
+      } catch (e) {
+        if (this.#connectionState === "closed") {
+          return;
+        }
+        if (attempt < maxAttempts && e instanceof McpError && e.code === ErrorCode.RequestTimeout) {
+          continue;
+        }
+        if (e instanceof McpError && e.code === ErrorCode.MethodNotFound) {
+          this.#logger.debug(
+            "[FastMCP debug] listRoots method not supported by client"
+          );
+        } else {
+          this.#logger.error(
+            `[FastMCP error] received error listing roots.
+
+${e instanceof Error ? e.stack : JSON.stringify(e)}`
+          );
+        }
+        return;
+      }
+    }
+  }
   /**
    * `sendLoggingMessage` rejects once the client has hung up, and these four
    * callers are synchronous, so the rejection has nowhere to go. Swallow it the
@@ -991,6 +984,67 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
       );
     });
   }
+  async #setUpSession(streamableHttp) {
+    if (!this.#stateless) {
+      let attempt = 0;
+      const maxAttempts = 10;
+      const retryDelay = 100;
+      while (attempt++ < maxAttempts) {
+        const capabilities = this.#server.getClientCapabilities();
+        if (capabilities) {
+          this.#clientCapabilities = capabilities;
+          break;
+        }
+        await delay(retryDelay);
+      }
+      if (!this.#clientCapabilities) {
+        this.#logger.warn(
+          `[FastMCP warning] could not infer client capabilities after ${maxAttempts} attempts. Connection may be unstable.`
+        );
+      }
+    }
+    if (this.#connectionState === "closed") {
+      return;
+    }
+    if (streamableHttp) {
+      void this.#loadRoots(true);
+    } else {
+      await this.#loadRoots(false);
+    }
+    if (this.#clientCapabilities) {
+      const pingConfig = this.#getPingConfig();
+      if (pingConfig.enabled) {
+        this.#pingInterval = setInterval(async () => {
+          if (this.#pingInFlight) {
+            return;
+          }
+          this.#pingInFlight = true;
+          try {
+            await this.#server.ping();
+          } catch {
+            const logLevel = pingConfig.logLevel;
+            if (logLevel === "debug") {
+              this.#logger.debug("[FastMCP debug] server ping failed");
+            } else if (logLevel === "warning") {
+              this.#logger.warn(
+                "[FastMCP warning] server is not responding to ping"
+              );
+            } else if (logLevel === "error") {
+              this.#logger.error(
+                "[FastMCP error] server is not responding to ping"
+              );
+            } else {
+              this.#logger.info("[FastMCP info] server ping failed");
+            }
+          } finally {
+            this.#pingInFlight = false;
+          }
+        }, pingConfig.intervalMs);
+      }
+    }
+    this.#connectionState = "ready";
+    this.emit("ready");
+  }
   /**
    * Periodically writes to the response stream of an in-flight tool call, so an
    * idle-connection timeout (proxy, load balancer) does not close it while a
@@ -1306,7 +1360,7 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
               const uriTemplate = parseURITemplate(
                 resourceTemplate.uriTemplate
               );
-              const match = uriTemplate.fromUri(request.params.uri);
+              const match = matchUriTemplate(uriTemplate, request.params.uri);
               if (!match) {
                 continue;
               }
@@ -1667,9 +1721,26 @@ function convertObjectToSnakeCase(obj) {
   }
   return result;
 }
+function isStreamableHttpTransport(transport) {
+  return "handleRequest" in transport && typeof transport.handleRequest === "function";
+}
 function joinPaths(basePath, path) {
   return `${basePath}${normalizePath(path)}`;
 }
+function matchUriTemplate(template, uri) {
+  const match = template.fromUri(uri);
+  if (!match) {
+    return void 0;
+  }
+  const checksQuery = !/\{[?&]/.test(template.template);
+  const checksFragment = !template.template.includes("{#");
+  const shape = (value) => [
+    value.split(/[?#]/, 1)[0].split("/").length,
+    checksQuery && value.includes("?"),
+    checksFragment && value.includes("#")
+  ].join();
+  return shape(template.fill(match)) === shape(uri) ? match : void 0;
+}
 function normalizeBasePath(path) {
   if (!path || path === "/") {
     return "";
@@ -1950,7 +2021,7 @@ var FastMCP = class extends FastMCPEventEmitter {
     }
     for (const template of this.#resourcesTemplates) {
       const parsedTemplate = parseURITemplate(template.uriTemplate);
-      const params = parsedTemplate.fromUri(uri);
+      const params = matchUriTemplate(parsedTemplate, uri);
       if (!params) {
         continue;
       }
@@ -3052,4 +3123,4 @@ export {
   FastMCPSession,
   FastMCP
 };
-//# sourceMappingURL=chunk-A6QGY7T7.js.map
+//# sourceMappingURL=chunk-NI4JFIL4.js.map