fastmcp 4.22.8 → 4.22.10

package/dist/{chunk-76QWMCYJ.js → chunk-RVBVCLCO.js}

@@ -668,10 +668,6 @@ var FastMCPSession = class extends FastMCPSessionEventEmitter {
     }
   }
   async close() {
-    this.#connectionState = "closed";
-    if (this.#pingInterval) {
-      clearInterval(this.#pingInterval);
-    }
     this.#abortSession();
     try {
       await this.#server.close();
@@ -828,11 +824,16 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
     });
   }
   /**
-   * Cancels the `signal` held by every tool still executing on this session.
-   * Idempotent, so the close path and the transport's own close handler can
-   * both call it.
+   * Marks the session closed, stops pinging the client and cancels the
+   * `signal` held by every tool still executing on this session. Idempotent,
+   * so the close path and the transport's own close handler can both call it.
    */
   #abortSession() {
+    this.#connectionState = "closed";
+    if (this.#pingInterval) {
+      clearInterval(this.#pingInterval);
+      this.#pingInterval = null;
+    }
     if (!this.#abortController.signal.aborted) {
       this.#abortController.abort(new SessionError("Session closed"));
     }
@@ -1013,6 +1014,9 @@ ${error instanceof Error ? error.stack : JSON.stringify(error)}`
       void this.#loadRoots(true);
     } else {
       await this.#loadRoots(false);
+      if (this.#abortController.signal.aborted) {
+        return;
+      }
     }
     if (this.#clientCapabilities) {
       const pingConfig = this.#getPingConfig();
@@ -1775,6 +1779,35 @@ function parseBasicAuthHeader(authHeader) {
     return null;
   }
 }
+function parseBooleanSetting(value, source) {
+  if (!value) {
+    return void 0;
+  }
+  switch (value.toLowerCase()) {
+    case "false":
+      return false;
+    case "true":
+      return true;
+    default:
+      throw new Error(`${source} must be "true" or "false", got "${value}"`);
+  }
+}
+function parseTransportSetting(value, source) {
+  if (!value) {
+    return void 0;
+  }
+  switch (value.toLowerCase()) {
+    case "http-stream":
+    case "httpstream":
+      return "httpStream";
+    case "stdio":
+      return "stdio";
+    default:
+      throw new Error(
+        `${source} must be "stdio", "httpStream" or "http-stream", got "${value}"`
+      );
+  }
+}
 function protectedResourceMetadataUrl(resource) {
   let url;
   try {
@@ -1972,7 +2005,8 @@ var FastMCP = class extends FastMCPEventEmitter {
    *
    * The transport's lifecycle belongs to the caller: `stop()` does not close
    * transports passed here. Close the returned session (or the transport) when
-   * you are done with it.
+   * you are done with it. If the client hangs up before the session is set up,
+   * the returned session is already closed and is not listed in `sessions`.
    *
    * @param transport - An already-constructed MCP server transport.
    * @param auth - Session auth, equivalent to what `authenticate` would return.
@@ -1980,21 +2014,7 @@ var FastMCP = class extends FastMCPEventEmitter {
    */
   async connect(transport, auth) {
     const session = this.#createSession(auth);
-    await session.connect(transport);
-    this.#sessions.push(session);
-    session.once("error", () => {
-      this.#removeSession(session);
-    });
-    const originalOnClose = transport.onclose;
-    transport.onclose = () => {
-      this.#removeSession(session);
-      if (originalOnClose) {
-        originalOnClose();
-      }
-    };
-    this.emit("connect", {
-      session
-    });
+    await this.#connectSession(session, transport);
     this.#serverState = "running" /* Running */;
     return session;
   }
@@ -2232,7 +2252,6 @@ var FastMCP = class extends FastMCPEventEmitter {
         version: this.#options.version,
         websiteUrl: this.#options.websiteUrl
       });
-      await session.connect(transport);
       let stdinClosed = false;
       const onStdinClose = () => {
         if (stdinClosed) return;
@@ -2244,29 +2263,9 @@ var FastMCP = class extends FastMCPEventEmitter {
       };
       process.stdin.on("close", onStdinClose);
       process.stdin.on("end", onStdinClose);
-      this.#sessions.push(session);
-      session.once("error", () => {
-        this.#removeSession(session);
-      });
-      if (transport.onclose) {
-        const originalOnClose = transport.onclose;
-        transport.onclose = () => {
-          process.stdin.off("close", onStdinClose);
-          process.stdin.off("end", onStdinClose);
-          this.#removeSession(session);
-          if (originalOnClose) {
-            originalOnClose();
-          }
-        };
-      } else {
-        transport.onclose = () => {
-          process.stdin.off("close", onStdinClose);
-          process.stdin.off("end", onStdinClose);
-          this.#removeSession(session);
-        };
-      }
-      this.emit("connect", {
-        session
+      await this.#connectSession(session, transport, () => {
+        process.stdin.off("close", onStdinClose);
+        process.stdin.off("end", onStdinClose);
       });
       this.#serverState = "running" /* Running */;
     } else if (config.transportType === "httpStream") {
@@ -2388,6 +2387,32 @@ var FastMCP = class extends FastMCPEventEmitter {
     }
     this.#serverState = "stopped" /* Stopped */;
   }
+  /**
+   * Connects `session` to `transport` and lists it in `sessions` until the
+   * transport closes. The close is watched from before the session connects,
+   * so a client that hangs up during setup leaves no session behind.
+   */
+  async #connectSession(session, transport, onClose) {
+    let closed = false;
+    const originalOnClose = transport.onclose;
+    transport.onclose = () => {
+      closed = true;
+      onClose?.();
+      this.#removeSession(session);
+      originalOnClose?.();
+    };
+    await session.connect(transport);
+    if (closed) {
+      return;
+    }
+    this.#sessions.push(session);
+    session.once("error", () => {
+      this.#removeSession(session);
+    });
+    this.emit("connect", {
+      session
+    });
+  }
   /**
    * Creates a new FastMCPSession instance with the current configuration.
    * Used both for regular sessions and stateless requests.
@@ -2982,8 +3007,17 @@ var FastMCP = class extends FastMCPEventEmitter {
   #parseRuntimeConfig(overrides) {
     const args = process.argv.slice(2);
     const getArg = (name) => {
-      const index = args.findIndex((arg) => arg === `--${name}`);
-      return index !== -1 && index + 1 < args.length ? args[index + 1] : void 0;
+      const index = args.findIndex(
+        (arg) => arg === `--${name}` || arg.startsWith(`--${name}=`)
+      );
+      if (index === -1) {
+        return void 0;
+      }
+      if (args[index] !== `--${name}`) {
+        return args[index].slice(name.length + 3);
+      }
+      const value = args[index + 1];
+      return value === void 0 || value.startsWith("--") ? "" : value;
     };
     const transportArg = getArg("transport");
     const portArg = getArg("port");
@@ -2997,7 +3031,7 @@ var FastMCP = class extends FastMCPEventEmitter {
     const envBasePath = process.env.FASTMCP_BASE_PATH;
     const envStateless = process.env.FASTMCP_STATELESS;
     const envHost = process.env.FASTMCP_HOST;
-    const transportType = overrides?.transportType || (transportArg === "http-stream" ? "httpStream" : transportArg) || envTransport || "stdio";
+    const transportType = overrides?.transportType || parseTransportSetting(transportArg, "--transport") || parseTransportSetting(envTransport, "FASTMCP_TRANSPORT") || "stdio";
     if (transportType === "httpStream") {
       const port = parseInt(
         overrides?.httpStream?.port?.toString() || portArg || envPort || "8080"
@@ -3008,7 +3042,8 @@ var FastMCP = class extends FastMCPEventEmitter {
         overrides?.httpStream?.basePath || basePathArg || envBasePath
       );
       const enableJsonResponse = overrides?.httpStream?.enableJsonResponse || false;
-      const stateless = overrides?.httpStream?.stateless ?? (statelessArg !== void 0 ? statelessArg === "true" : envStateless === "true");
+      const stateless = overrides?.httpStream?.stateless ?? // A bare `--stateless` means `--stateless true`.
+      (statelessArg === "" ? true : parseBooleanSetting(statelessArg, "--stateless")) ?? parseBooleanSetting(envStateless, "FASTMCP_STATELESS") ?? false;
       const cors = overrides?.httpStream?.cors;
       const eventStore = overrides?.httpStream?.eventStore;
       const sslCa = overrides?.httpStream?.sslCa;
@@ -3134,4 +3169,4 @@ export {
   FastMCPSession,
   FastMCP
 };
-//# sourceMappingURL=chunk-76QWMCYJ.js.map
+//# sourceMappingURL=chunk-RVBVCLCO.js.map