fastmcp 2.10.6__py3-none-any.whl → 2.11.0__py3-none-any.whl

fastmcp/cli/run.py

@@ -1,11 +1,17 @@
 """FastMCP run command implementation with enhanced type hints."""
 
 import importlib.util
+import json
 import re
+import subprocess
 import sys
+from functools import partial
 from pathlib import Path
 from typing import Any, Literal
 
+from mcp.server.fastmcp import FastMCP as FastMCP1x
+
+from fastmcp.server.server import FastMCP
 from fastmcp.utilities.logging import get_logger
 
 logger = get_logger("cli.run")
@@ -122,6 +128,84 @@ def import_server(file: Path, server_object: str | None = None) -> Any:
     return server
 
 
+def run_with_uv(
+    server_spec: str,
+    python_version: str | None = None,
+    with_packages: list[str] | None = None,
+    with_requirements: Path | None = None,
+    project: Path | None = None,
+    transport: TransportType | None = None,
+    host: str | None = None,
+    port: int | None = None,
+    path: str | None = None,
+    log_level: LogLevelType | None = None,
+    show_banner: bool = True,
+) -> None:
+    """Run a MCP server using uv run subprocess.
+
+    Args:
+        server_spec: Python file, object specification (file:obj), or URL
+        python_version: Python version to use (e.g. "3.10")
+        with_packages: Additional packages to install
+        with_requirements: Requirements file to use
+        project: Run the command within the given project directory
+        transport: Transport protocol to use
+        host: Host to bind to when using http transport
+        port: Port to bind to when using http transport
+        path: Path to bind to when using http transport
+        log_level: Log level
+        show_banner: Whether to show the server banner
+    """
+    cmd = ["uv", "run"]
+
+    # Add Python version if specified
+    if python_version:
+        cmd.extend(["--python", python_version])
+
+    # Add project if specified
+    if project:
+        cmd.extend(["--project", str(project)])
+
+    # Add fastmcp package
+    cmd.extend(["--with", "fastmcp"])
+
+    # Add additional packages
+    if with_packages:
+        for pkg in with_packages:
+            if pkg:
+                cmd.extend(["--with", pkg])
+
+    # Add requirements file
+    if with_requirements:
+        cmd.extend(["--with-requirements", str(with_requirements)])
+
+    # Add fastmcp run command
+    cmd.extend(["fastmcp", "run", server_spec])
+
+    # Add transport options
+    if transport:
+        cmd.extend(["--transport", transport])
+    if host:
+        cmd.extend(["--host", host])
+    if port:
+        cmd.extend(["--port", str(port)])
+    if path:
+        cmd.extend(["--path", path])
+    if log_level:
+        cmd.extend(["--log-level", log_level])
+    if not show_banner:
+        cmd.append("--no-banner")
+
+    # Run the command
+    logger.debug(f"Running command: {' '.join(cmd)}")
+    try:
+        process = subprocess.run(cmd, check=True)
+        sys.exit(process.returncode)
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to run server: {e}")
+        sys.exit(e.returncode)
+
+
 def create_client_server(url: str) -> Any:
     """Create a FastMCP server from a client URL.
 
@@ -142,6 +226,17 @@ def create_client_server(url: str) -> Any:
         sys.exit(1)
 
 
+def create_mcp_config_server(mcp_config_path: Path) -> FastMCP[None]:
+    """Create a FastMCP server from a MCPConfig."""
+    from fastmcp import FastMCP
+
+    with mcp_config_path.open() as src:
+        mcp_config = json.load(src)
+
+    server = FastMCP.as_proxy(mcp_config)
+    return server
+
+
 def import_server_with_args(
     file: Path, server_object: str | None = None, server_args: list[str] | None = None
 ) -> Any:
@@ -175,11 +270,12 @@ def run_command(
     log_level: LogLevelType | None = None,
     server_args: list[str] | None = None,
     show_banner: bool = True,
+    use_direct_import: bool = False,
 ) -> None:
     """Run a MCP server or connect to a remote one.
 
     Args:
-        server_spec: Python file, object specification (file:obj), or URL
+        server_spec: Python file, object specification (file:obj), MCPConfig file, or URL
         transport: Transport protocol to use
         host: Host to bind to when using http transport
         port: Port to bind to when using http transport
@@ -187,11 +283,14 @@ def run_command(
         log_level: Log level
         server_args: Additional arguments to pass to the server
         show_banner: Whether to show the server banner
+        use_direct_import: Whether to use direct import instead of subprocess
     """
     if is_url(server_spec):
         # Handle URL case
         server = create_client_server(server_spec)
         logger.debug(f"Created client proxy server for {server_spec}")
+    elif server_spec.endswith(".json"):
+        server = create_mcp_config_server(Path(server_spec))
     else:
         # Handle file case
         file, server_object = parse_file_path(server_spec)
@@ -199,6 +298,12 @@ def run_command(
         logger.debug(f'Found server "{server.name}" in {file}')
 
     # Run the server
+
+    # handle v1 servers
+    if isinstance(server, FastMCP1x):
+        run_v1_server(server, host=host, port=port, transport=transport)
+        return
+
     kwargs = {}
     if transport:
         kwargs["transport"] = transport
@@ -219,3 +324,24 @@ def run_command(
     except Exception as e:
         logger.error(f"Failed to run server: {e}")
         sys.exit(1)
+
+
+def run_v1_server(
+    server: FastMCP1x,
+    host: str | None = None,
+    port: int | None = None,
+    transport: TransportType | None = None,
+) -> None:
+    if host:
+        server.settings.host = host
+    if port:
+        server.settings.port = port
+    match transport:
+        case "stdio":
+            runner = partial(server.run)
+        case "http" | "streamable-http" | None:
+            runner = partial(server.run, transport="streamable-http")
+        case "sse":
+            runner = partial(server.run, transport="sse")
+
+    runner()

fastmcp/client/__init__.py

@@ -7,6 +7,7 @@ from .transports import (
     PythonStdioTransport,
     NodeStdioTransport,
     UvxStdioTransport,
+    UvStdioTransport,
     NpxStdioTransport,
     FastMCPTransport,
     StreamableHttpTransport,
@@ -22,6 +23,7 @@ __all__ = [
     "PythonStdioTransport",
     "NodeStdioTransport",
     "UvxStdioTransport",
+    "UvStdioTransport",
     "NpxStdioTransport",
     "FastMCPTransport",
     "StreamableHttpTransport",

fastmcp/client/auth/oauth.py

@@ -5,7 +5,7 @@ import json
 import webbrowser
 from pathlib import Path
 from typing import Any, Literal
-from urllib.parse import urljoin, urlparse
+from urllib.parse import urlparse
 
 import anyio
 import httpx
@@ -13,7 +13,6 @@ from mcp.client.auth import OAuthClientProvider, TokenStorage
 from mcp.shared.auth import (
     OAuthClientInformationFull,
     OAuthClientMetadata,
-    OAuthMetadata,
 )
 from mcp.shared.auth import (
     OAuthToken as OAuthToken,
@@ -150,41 +149,6 @@ class FileTokenStorage(TokenStorage):
         logger.info("Cleared all OAuth client cache data.")
 
 
-async def discover_oauth_metadata(
-    server_base_url: str, httpx_kwargs: dict[str, Any] | None = None
-) -> OAuthMetadata | None:
-    """
-    Discover OAuth metadata from the server using RFC 8414 well-known endpoint.
-
-    Args:
-        server_base_url: Base URL of the OAuth server (e.g., "https://example.com")
-        httpx_kwargs: Additional kwargs for httpx client
-
-    Returns:
-        OAuth metadata if found, None otherwise
-    """
-    well_known_url = urljoin(server_base_url, "/.well-known/oauth-authorization-server")
-    logger.debug(f"Discovering OAuth metadata from: {well_known_url}")
-
-    async with httpx.AsyncClient(**(httpx_kwargs or {})) as client:
-        try:
-            response = await client.get(well_known_url, timeout=10.0)
-            if response.status_code == 200:
-                logger.debug("Successfully discovered OAuth metadata")
-                return OAuthMetadata.model_validate(response.json())
-            elif response.status_code == 404:
-                logger.debug(
-                    "OAuth metadata not found (404) - server may not require auth"
-                )
-                return None
-            else:
-                logger.warning(f"OAuth metadata request failed: {response.status_code}")
-                return None
-        except (httpx.RequestError, json.JSONDecodeError, ValidationError) as e:
-            logger.debug(f"OAuth metadata discovery failed: {e}")
-            return None
-
-
 async def check_if_auth_required(
     mcp_url: str, httpx_kwargs: dict[str, Any] | None = None
 ) -> bool:
@@ -215,70 +179,86 @@ async def check_if_auth_required(
             return True
 
 
-def OAuth(
-    mcp_url: str,
-    scopes: str | list[str] | None = None,
-    client_name: str = "FastMCP Client",
-    token_storage_cache_dir: Path | None = None,
-    additional_client_metadata: dict[str, Any] | None = None,
-) -> OAuthClientProvider:
+class OAuth(OAuthClientProvider):
     """
-    Create an OAuthClientProvider for an MCP server.
+    OAuth client provider for MCP servers with browser-based authentication.
 
-    This is intended to be provided to the `auth` parameter of an
-    httpx.AsyncClient (or appropriate FastMCP client/transport instance)
+    This class provides OAuth authentication for FastMCP clients by opening
+    a browser for user authorization and running a local callback server.
+    """
 
-    Args:
-        mcp_url: Full URL to the MCP endpoint (e.g. "http://host/mcp/sse/")
-        scopes: OAuth scopes to request. Can be a
-        space-separated string or a list of strings.
-        client_name: Name for this client during registration
-        token_storage_cache_dir: Directory for FileTokenStorage
-        additional_client_metadata: Extra fields for OAuthClientMetadata
+    def __init__(
+        self,
+        mcp_url: str,
+        scopes: str | list[str] | None = None,
+        client_name: str = "FastMCP Client",
+        token_storage_cache_dir: Path | None = None,
+        additional_client_metadata: dict[str, Any] | None = None,
+        callback_port: int | None = None,
+    ):
+        """
+        Initialize OAuth client provider for an MCP server.
+
+        Args:
+            mcp_url: Full URL to the MCP endpoint (e.g. "http://host/mcp/sse/")
+            scopes: OAuth scopes to request. Can be a
+            space-separated string or a list of strings.
+            client_name: Name for this client during registration
+            token_storage_cache_dir: Directory for FileTokenStorage
+            additional_client_metadata: Extra fields for OAuthClientMetadata
+            callback_port: Fixed port for OAuth callback (default: random available port)
+        """
+        parsed_url = urlparse(mcp_url)
+        server_base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
+
+        # Setup OAuth client
+        self.redirect_port = callback_port or find_available_port()
+        redirect_uri = f"http://localhost:{self.redirect_port}/callback"
+
+        if isinstance(scopes, list):
+            scopes = " ".join(scopes)
+
+        client_metadata = OAuthClientMetadata(
+            client_name=client_name,
+            redirect_uris=[AnyHttpUrl(redirect_uri)],
+            grant_types=["authorization_code", "refresh_token"],
+            response_types=["code"],
+            # token_endpoint_auth_method="client_secret_post",
+            scope=scopes,
+            **(additional_client_metadata or {}),
+        )
 
-    Returns:
-        OAuthClientProvider
-    """
-    parsed_url = urlparse(mcp_url)
-    server_base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
-
-    # Setup OAuth client
-    redirect_port = find_available_port()
-    redirect_uri = f"http://127.0.0.1:{redirect_port}/callback"
-
-    if isinstance(scopes, list):
-        scopes = " ".join(scopes)
-
-    client_metadata = OAuthClientMetadata(
-        client_name=client_name,
-        redirect_uris=[AnyHttpUrl(redirect_uri)],
-        grant_types=["authorization_code", "refresh_token"],
-        response_types=["code"],
-        token_endpoint_auth_method="client_secret_post",
-        scope=scopes,
-        **(additional_client_metadata or {}),
-    )
-
-    # Create server-specific token storage
-    storage = FileTokenStorage(
-        server_url=server_base_url, cache_dir=token_storage_cache_dir
-    )
-
-    # Define OAuth handlers
-    async def redirect_handler(authorization_url: str) -> None:
+        # Create server-specific token storage
+        storage = FileTokenStorage(
+            server_url=server_base_url, cache_dir=token_storage_cache_dir
+        )
+
+        # Store server_base_url for use in callback_handler
+        self.server_base_url = server_base_url
+
+        # Initialize parent class
+        super().__init__(
+            server_url=server_base_url,
+            client_metadata=client_metadata,
+            storage=storage,
+            redirect_handler=self.redirect_handler,
+            callback_handler=self.callback_handler,
+        )
+
+    async def redirect_handler(self, authorization_url: str) -> None:
         """Open browser for authorization."""
         logger.info(f"OAuth authorization URL: {authorization_url}")
         webbrowser.open(authorization_url)
 
-    async def callback_handler() -> tuple[str, str | None]:
+    async def callback_handler(self) -> tuple[str, str | None]:
         """Handle OAuth callback and return (auth_code, state)."""
         # Create a future to capture the OAuth response
         response_future = asyncio.get_running_loop().create_future()
 
         # Create server with the future
         server = create_oauth_callback_server(
-            port=redirect_port,
-            server_url=server_base_url,
+            port=self.redirect_port,
+            server_url=self.server_base_url,
             response_future=response_future,
         )
 
@@ -286,7 +266,7 @@ def OAuth(
         async with anyio.create_task_group() as tg:
             tg.start_soon(server.serve)
             logger.info(
-                f"🎧 OAuth callback server started on http://127.0.0.1:{redirect_port}"
+                f"🎧 OAuth callback server started on http://localhost:{self.redirect_port}"
             )
 
             TIMEOUT = 300.0  # 5 minute timeout
@@ -300,14 +280,3 @@ def OAuth(
                 server.should_exit = True
                 await asyncio.sleep(0.1)  # Allow server to shutdown gracefully
                 tg.cancel_scope.cancel()
-
-    # Create OAuth provider
-    oauth_provider = OAuthClientProvider(
-        server_url=server_base_url,
-        client_metadata=client_metadata,
-        storage=storage,
-        redirect_handler=redirect_handler,
-        callback_handler=callback_handler,
-    )
-
-    return oauth_provider

fastmcp/client/oauth_callback.py

@@ -252,6 +252,24 @@ def create_oauth_callback_server(
                 status_code=400,
             )
 
+        # Check for missing state parameter (indicates OAuth flow issue)
+        if callback_response.state is None:
+            # Resolve future with exception if provided
+            if response_future and not response_future.done():
+                response_future.set_exception(
+                    RuntimeError(
+                        "OAuth server did not return state parameter - authentication failed"
+                    )
+                )
+
+            return HTMLResponse(
+                create_callback_html(
+                    "FastMCP OAuth Error: Authentication failed<br>The OAuth server did not return the expected state parameter",
+                    is_success=False,
+                ),
+                status_code=400,
+            )
+
         # Success case
         if response_future and not response_future.done():
             response_future.set_result(

fastmcp/client/transports.py

@@ -48,6 +48,7 @@ __all__ = [
     "FastMCPStdioTransport",
     "NodeStdioTransport",
     "UvxStdioTransport",
+    "UvStdioTransport",
     "NpxStdioTransport",
     "FastMCPTransport",
     "infer_transport",
@@ -542,6 +543,63 @@ class NodeStdioTransport(StdioTransport):
         self.script_path = script_path
 
 
+class UvStdioTransport(StdioTransport):
+    """Transport for running commands via the uv tool."""
+
+    def __init__(
+        self,
+        command: str,
+        args: list[str] | None = None,
+        module: bool = False,
+        project_directory: str | None = None,
+        python_version: str | None = None,
+        with_packages: list[str] | None = None,
+        with_requirements: str | None = None,
+        env_vars: dict[str, str] | None = None,
+        keep_alive: bool | None = None,
+    ):
+        # Basic validation
+        if project_directory and not Path(project_directory).exists():
+            raise NotADirectoryError(
+                f"Project directory not found: {project_directory}"
+            )
+
+        # Build uv arguments
+        uv_args: list[str] = ["run"]
+        if project_directory:
+            uv_args.extend(["--directory", str(project_directory)])
+        if python_version:
+            uv_args.extend(["--python", python_version])
+        for pkg in with_packages or []:
+            uv_args.extend(["--with", pkg])
+        if with_requirements:
+            uv_args.extend(["--with-requirements", str(with_requirements)])
+        if module:
+            uv_args.append("--module")
+
+        if not args:
+            args = []
+
+        uv_args.extend([command, *args])
+
+        # Get environment with any additional variables
+        env: dict[str, str] | None = None
+        if env_vars or project_directory:
+            env = os.environ.copy()
+            if project_directory:
+                env["UV_PROJECT_DIR"] = str(project_directory)
+            if env_vars:
+                env.update(env_vars)
+
+        super().__init__(
+            command="uv",
+            args=uv_args,
+            env=env,
+            cwd=None,  # Use --directory flag instead of cwd
+            keep_alive=keep_alive,
+        )
+
+
 class UvxStdioTransport(StdioTransport):
     """Transport for running commands via the uvx tool."""
 
@@ -579,7 +637,7 @@ class UvxStdioTransport(StdioTransport):
             )
 
         # Build uvx arguments
-        uvx_args = []
+        uvx_args: list[str] = []
         if python_version:
             uvx_args.extend(["--python", python_version])
         if from_package:
@@ -592,11 +650,9 @@ class UvxStdioTransport(StdioTransport):
         if tool_args:
             uvx_args.extend(tool_args)
 
-        # Get environment with any additional variables
-        env = None
+        env: dict[str, str] | None = None
         if env_vars:
             env = os.environ.copy()
-            env.update(env_vars)
 
         super().__init__(
             command="uvx",
@@ -605,7 +661,7 @@ class UvxStdioTransport(StdioTransport):
             cwd=project_directory,
             keep_alive=keep_alive,
         )
-        self.tool_name = tool_name
+        self.tool_name: str = tool_name
 
 
 class NpxStdioTransport(StdioTransport):
@@ -732,7 +788,7 @@ class MCPConfigTransport(ClientTransport):
 
     1. If the MCPConfig contains exactly one server, it creates a direct transport to that server.
     2. If the MCPConfig contains multiple servers, it creates a composite client by mounting
-       all servers on a single FastMCP instance, with each server's name used as its mounting prefix.
+       all servers on a single FastMCP instance, with each server's name, by default, used as its mounting prefix.
 
     In the multi-server case, tools are accessible with the prefix pattern `{server_name}_{tool_name}`
     and resources with the pattern `protocol://{server_name}/path/to/resource`.
@@ -772,7 +828,9 @@ class MCPConfigTransport(ClientTransport):
         ```
     """
 
-    def __init__(self, config: MCPConfig | dict):
+    def __init__(self, config: MCPConfig | dict, name_as_prefix: bool = True):
+        from fastmcp.utilities.mcp_config import composite_server_from_mcp_config
+
         if isinstance(config, dict):
             config = MCPConfig.from_dict(config)
         self.config = config
@@ -787,15 +845,11 @@ class MCPConfigTransport(ClientTransport):
 
         # otherwise create a composite client
         else:
-            composite_server = FastMCP()
-
-            for name, server in self.config.mcpServers.items():
-                composite_server.mount(
-                    prefix=name,
-                    server=FastMCP.as_proxy(backend=server.to_transport()),
+            self.transport = FastMCPTransport(
+                mcp=composite_server_from_mcp_config(
+                    self.config, name_as_prefix=name_as_prefix
                 )
-
-            self.transport = FastMCPTransport(mcp=composite_server)
+            )
 
     @contextlib.asynccontextmanager
     async def connect_session(

fastmcp/contrib/component_manager/example.py

@@ -1,10 +1,10 @@
 from fastmcp import FastMCP
 from fastmcp.contrib.component_manager import set_up_component_manager
-from fastmcp.server.auth.providers.bearer import BearerAuthProvider, RSAKeyPair
+from fastmcp.server.auth.providers.jwt import JWTVerifier, RSAKeyPair
 
 key_pair = RSAKeyPair.generate()
 
-auth = BearerAuthProvider(
+auth = JWTVerifier(
     public_key=key_pair.public_key,
     issuer="https://dev.example.com",
     audience="my-dev-server",