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

fastmcp/cli/cli.py

@@ -138,7 +138,7 @@ def version(
 
 
 @app.command
-def dev(
+async def dev(
     server_spec: str,
     *,
     with_editable: Annotated[
@@ -220,7 +220,7 @@ def dev(
 
     try:
         # Import server to get dependencies
-        server: FastMCP = run_module.import_server(file, server_object)
+        server: FastMCP = await run_module.import_server(file, server_object)
         if server.dependencies is not None:
             with_packages = list(set(with_packages + server.dependencies))
 
@@ -283,7 +283,7 @@ def dev(
 
 
 @app.command
-def run(
+async def run(
     server_spec: str,
     *server_args: str,
     transport: Annotated[
@@ -414,7 +414,7 @@ def run(
     else:
         # Use direct import for backwards compatibility
         try:
-            run_module.run_command(
+            await run_module.run_command(
                 server_spec=server_spec,
                 transport=transport,
                 host=host,
@@ -476,7 +476,7 @@ async def inspect(
 
     try:
         # Import the server
-        server = run_module.import_server(file, server_object)
+        server = await run_module.import_server(file, server_object)
 
         # Get server information - using native async support
         info = await inspect_fastmcp(server)

fastmcp/cli/install/claude_code.py

@@ -167,7 +167,7 @@ def install_claude_code(
         return False
 
 
-def claude_code_command(
+async def claude_code_command(
     server_spec: str,
     *,
     server_name: Annotated[
@@ -234,7 +234,7 @@ def claude_code_command(
     Args:
         server_spec: Python file to install, optionally with :object suffix
     """
-    file, server_object, name, packages, env_dict = process_common_args(
+    file, server_object, name, packages, env_dict = await process_common_args(
         server_spec, server_name, with_packages, env_vars, env_file
     )
 

fastmcp/cli/install/claude_desktop.py

@@ -140,7 +140,7 @@ def install_claude_desktop(
         return False
 
 
-def claude_desktop_command(
+async def claude_desktop_command(
     server_spec: str,
     *,
     server_name: Annotated[
@@ -207,7 +207,7 @@ def claude_desktop_command(
     Args:
         server_spec: Python file to install, optionally with :object suffix
     """
-    file, server_object, name, with_packages, env_dict = process_common_args(
+    file, server_object, name, with_packages, env_dict = await process_common_args(
         server_spec, server_name, with_packages, env_vars, env_file
     )
 

fastmcp/cli/install/cursor.py

@@ -150,7 +150,7 @@ def install_cursor(
         return False
 
 
-def cursor_command(
+async def cursor_command(
     server_spec: str,
     *,
     server_name: Annotated[
@@ -217,7 +217,7 @@ def cursor_command(
     Args:
         server_spec: Python file to install, optionally with :object suffix
     """
-    file, server_object, name, with_packages, env_dict = process_common_args(
+    file, server_object, name, with_packages, env_dict = await process_common_args(
         server_spec, server_name, with_packages, env_vars, env_file
     )
 

fastmcp/cli/install/mcp_json.py

@@ -113,7 +113,7 @@ def install_mcp_json(
         return False
 
 
-def mcp_json_command(
+async def mcp_json_command(
     server_spec: str,
     *,
     server_name: Annotated[
@@ -188,7 +188,7 @@ def mcp_json_command(
     Args:
         server_spec: Python file to install, optionally with :object suffix
     """
-    file, server_object, name, packages, env_dict = process_common_args(
+    file, server_object, name, packages, env_dict = await process_common_args(
         server_spec, server_name, with_packages, env_vars, env_file
     )
 

fastmcp/cli/install/shared.py

@@ -23,7 +23,7 @@ def parse_env_var(env_var: str) -> tuple[str, str]:
     return key.strip(), value.strip()
 
 
-def process_common_args(
+async def process_common_args(
     server_spec: str,
     server_name: str | None,
     with_packages: list[str],
@@ -49,7 +49,7 @@ def process_common_args(
     server = None
     if not name:
         try:
-            server = import_server(file, server_object)
+            server = await import_server(file, server_object)
             name = server.name
         except (ImportError, ModuleNotFoundError) as e:
             logger.debug(

fastmcp/cli/run.py

@@ -1,6 +1,7 @@
 """FastMCP run command implementation with enhanced type hints."""
 
 import importlib.util
+import inspect
 import json
 import re
 import subprocess
@@ -58,15 +59,15 @@ def parse_file_path(server_spec: str) -> tuple[Path, str | None]:
     return file_path, server_object
 
 
-def import_server(file: Path, server_object: str | None = None) -> Any:
+async def import_server(file: Path, server_or_factory: str | None = None) -> Any:
     """Import a MCP server from a file.
 
     Args:
         file: Path to the file
-        server_object: Optional object name in format "module:object" or just "object"
+        server_or_factory: Optional object name in format "module:object" or just "object"
 
     Returns:
-        The server object
+        The server object (or result of calling a factory function)
     """
     # Add parent directory to Python path so imports can be resolved
     file_dir = str(file.parent)
@@ -86,11 +87,12 @@ def import_server(file: Path, server_object: str | None = None) -> Any:
     spec.loader.exec_module(module)
 
     # If no object specified, try common server names
-    if not server_object:
-        # Look for the most common server object names
+    if not server_or_factory:
+        # Look for common server instance names
         for name in ["mcp", "server", "app"]:
             if hasattr(module, name):
-                return getattr(module, name)
+                obj = getattr(module, name)
+                return await _resolve_server_or_factory(obj, file, name)
 
         logger.error(
             f"No server object found in {file}. Please either:\n"
@@ -100,14 +102,14 @@ def import_server(file: Path, server_object: str | None = None) -> Any:
         )
         sys.exit(1)
 
-    assert server_object is not None
+    assert server_or_factory is not None
 
     # Handle module:object syntax
-    if ":" in server_object:
-        module_name, object_name = server_object.split(":", 1)
+    if ":" in server_or_factory:
+        module_name, object_name = server_or_factory.split(":", 1)
         try:
             server_module = importlib.import_module(module_name)
-            server = getattr(server_module, object_name, None)
+            obj = getattr(server_module, object_name, None)
         except ImportError:
             logger.error(
                 f"Could not import module '{module_name}'",
@@ -116,16 +118,62 @@ def import_server(file: Path, server_object: str | None = None) -> Any:
             sys.exit(1)
     else:
         # Just object name
-        server = getattr(module, server_object, None)
+        obj = getattr(module, server_or_factory, None)
 
-    if server is None:
+    if obj is None:
         logger.error(
-            f"Server object '{server_object}' not found",
+            f"Server object '{server_or_factory}' not found",
             extra={"file": str(file)},
         )
         sys.exit(1)
 
-    return server
+    return await _resolve_server_or_factory(obj, file, server_or_factory)
+
+
+async def _resolve_server_or_factory(obj: Any, file: Path, name: str) -> Any:
+    """Resolve a server object or factory function to a server instance.
+
+    Args:
+        obj: The object that might be a server or factory function
+        file: Path to the file for error messages
+        name: Name of the object for error messages
+
+    Returns:
+        A server instance
+    """
+    # Check if it's a function or coroutine function
+    if inspect.isfunction(obj) or inspect.iscoroutinefunction(obj):
+        logger.debug(f"Found factory function '{name}' in {file}")
+
+        try:
+            if inspect.iscoroutinefunction(obj):
+                # Async factory function
+                server = await obj()
+            else:
+                # Sync factory function
+                server = obj()
+
+            # Validate the result is a FastMCP server
+            if not isinstance(server, FastMCP | FastMCP1x):
+                logger.error(
+                    f"Factory function '{name}' must return a FastMCP server instance, "
+                    f"got {type(server).__name__}",
+                    extra={"file": str(file)},
+                )
+                sys.exit(1)
+
+            logger.debug(f"Factory function '{name}' created server: {server.name}")
+            return server
+
+        except Exception as e:
+            logger.error(
+                f"Failed to call factory function '{name}': {e}",
+                extra={"file": str(file)},
+            )
+            sys.exit(1)
+
+    # Not a function, return as-is (should be a server instance)
+    return obj
 
 
 def run_with_uv(
@@ -219,7 +267,7 @@ def create_client_server(url: str) -> Any:
         import fastmcp
 
         client = fastmcp.Client(url)
-        server = fastmcp.FastMCP.from_client(client)
+        server = fastmcp.FastMCP.as_proxy(client)
         return server
     except Exception as e:
         logger.error(f"Failed to create client for URL {url}: {e}")
@@ -237,14 +285,16 @@ def create_mcp_config_server(mcp_config_path: Path) -> FastMCP[None]:
     return server
 
 
-def import_server_with_args(
-    file: Path, server_object: str | None = None, server_args: list[str] | None = None
+async def import_server_with_args(
+    file: Path,
+    server_or_factory: str | None = None,
+    server_args: list[str] | None = None,
 ) -> Any:
     """Import a server with optional command line arguments.
 
     Args:
         file: Path to the server file
-        server_object: Optional server object name
+        server_or_factory: Optional server object or factory function name
         server_args: Optional command line arguments to inject
 
     Returns:
@@ -254,14 +304,14 @@ def import_server_with_args(
         original_argv = sys.argv[:]
         try:
             sys.argv = [str(file)] + server_args
-            return import_server(file, server_object)
+            return await import_server(file, server_or_factory)
         finally:
             sys.argv = original_argv
     else:
-        return import_server(file, server_object)
+        return await import_server(file, server_or_factory)
 
 
-def run_command(
+async def run_command(
     server_spec: str,
     transport: TransportType | None = None,
     host: str | None = None,
@@ -293,8 +343,8 @@ def run_command(
         server = create_mcp_config_server(Path(server_spec))
     else:
         # Handle file case
-        file, server_object = parse_file_path(server_spec)
-        server = import_server_with_args(file, server_object, server_args)
+        file, server_or_factory = parse_file_path(server_spec)
+        server = await import_server_with_args(file, server_or_factory, server_args)
         logger.debug(f'Found server "{server.name}" in {file}')
 
     # Run the server
@@ -320,7 +370,7 @@ def run_command(
         kwargs["show_banner"] = False
 
     try:
-        server.run(**kwargs)
+        await server.run_async(**kwargs)
     except Exception as e:
         logger.error(f"Failed to run server: {e}")
         sys.exit(1)

fastmcp/server/auth/__init__.py

@@ -1,4 +1,4 @@
-from .auth import OAuthProvider, TokenVerifier
+from .auth import OAuthProvider, TokenVerifier, RemoteAuthProvider
 from .providers.jwt import JWTVerifier, StaticTokenVerifier
 
 
@@ -7,6 +7,7 @@ __all__ = [
     "TokenVerifier",
     "JWTVerifier",
     "StaticTokenVerifier",
+    "RemoteAuthProvider",
 ]
 
 

fastmcp/server/auth/auth.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
 from mcp.server.auth.provider import (
     AccessToken,
     AuthorizationCode,
@@ -11,6 +9,10 @@ from mcp.server.auth.provider import (
 from mcp.server.auth.provider import (
     TokenVerifier as TokenVerifierProtocol,
 )
+from mcp.server.auth.routes import (
+    create_auth_routes,
+    create_protected_resource_routes,
+)
 from mcp.server.auth.settings import (
     ClientRegistrationOptions,
     RevocationOptions,
@@ -18,11 +20,8 @@ from mcp.server.auth.settings import (
 from pydantic import AnyHttpUrl
 from starlette.routing import Route
 
-if TYPE_CHECKING:
-    pass
-
 
-class AuthProvider:
+class AuthProvider(TokenVerifierProtocol):
     """Base class for all FastMCP authentication providers.
 
     This class provides a unified interface for all authentication providers,
@@ -31,9 +30,18 @@ class AuthProvider:
     custom authentication routes.
     """
 
-    def __init__(self, required_scopes: list[str] | None = None):
-        """Initialize the auth provider."""
-        self.required_scopes: list[str] = required_scopes or []
+    def __init__(self, resource_server_url: AnyHttpUrl | str | None = None):
+        """
+        Initialize the auth provider.
+
+        Args:
+            resource_server_url: The URL of this resource server. This is used
+            for RFC 8707 resource indicators, including creating the WWW-Authenticate
+            header.
+        """
+        if isinstance(resource_server_url, str):
+            resource_server_url = AnyHttpUrl(resource_server_url)
+        self.resource_server_url = resource_server_url
 
     async def verify_token(self, token: str) -> AccessToken | None:
         """Verify a bearer token and return access info if valid.
@@ -48,22 +56,34 @@ class AuthProvider:
         """
         raise NotImplementedError("Subclasses must implement verify_token")
 
-    def customize_auth_routes(self, routes: list[Route]) -> list[Route]:
-        """Customize authentication routes after standard creation.
+    def get_routes(self) -> list[Route]:
+        """Get the routes for this authentication provider.
 
-        This method allows providers to modify or add to the standard OAuth routes.
-        The default implementation returns the routes unchanged.
-
-        Args:
-            routes: List of standard routes (may be empty for token-only providers)
+        Each provider is responsible for creating whatever routes it needs:
+        - TokenVerifier: typically no routes (default implementation)
+        - RemoteAuthProvider: protected resource metadata routes
+        - OAuthProvider: full OAuth authorization server routes
+        - Custom providers: whatever routes they need
 
         Returns:
-            List of routes (potentially modified or extended)
+            List of routes for this provider
         """
-        return routes
+        return []
+
+    def get_resource_metadata_url(self) -> AnyHttpUrl | None:
+        """Get the resource metadata URL for RFC 9728 compliance."""
+        if self.resource_server_url is None:
+            return None
 
+        # Add .well-known path for RFC 9728 compliance
+        resource_metadata_url = AnyHttpUrl(
+            str(self.resource_server_url).rstrip("/")
+            + "/.well-known/oauth-protected-resource"
+        )
+        return resource_metadata_url
 
-class TokenVerifier(AuthProvider, TokenVerifierProtocol):
+
+class TokenVerifier(AuthProvider):
     """Base class for token verifiers (Resource Servers).
 
     This class provides token verification capability without OAuth server functionality.
@@ -79,26 +99,71 @@ class TokenVerifier(AuthProvider, TokenVerifierProtocol):
         Initialize the token verifier.
 
         Args:
-            resource_server_url: The URL of this resource server (for RFC 8707 resource indicators)
+            resource_server_url: The URL of this resource server. This is used
+            for RFC 8707 resource indicators, including creating the WWW-Authenticate
+            header.
             required_scopes: Scopes that are required for all requests
         """
-        # Initialize AuthProvider (no args needed)
-        AuthProvider.__init__(self, required_scopes=required_scopes)
-
-        # Handle our own resource_server_url and required_scopes
-        self.resource_server_url: AnyHttpUrl | None
-        if resource_server_url is None:
-            self.resource_server_url = None
-        elif isinstance(resource_server_url, str):
-            self.resource_server_url = AnyHttpUrl(resource_server_url)
-        else:
-            self.resource_server_url = resource_server_url
+        super().__init__(resource_server_url=resource_server_url)
+        self.required_scopes = required_scopes or []
 
     async def verify_token(self, token: str) -> AccessToken | None:
         """Verify a bearer token and return access info if valid."""
         raise NotImplementedError("Subclasses must implement verify_token")
 
 
+class RemoteAuthProvider(AuthProvider):
+    """Authentication provider for resource servers that verify tokens from known authorization servers.
+
+    This provider composes a TokenVerifier with authorization server metadata to create
+    standardized OAuth 2.0 Protected Resource endpoints (RFC 9728). Perfect for:
+    - JWT verification with known issuers
+    - Remote token introspection services
+    - Any resource server that knows where its tokens come from
+
+    Use this when you have token verification logic and want to advertise
+    the authorization servers that issue valid tokens.
+    """
+
+    def __init__(
+        self,
+        token_verifier: TokenVerifier,
+        authorization_servers: list[AnyHttpUrl],
+        resource_server_url: AnyHttpUrl | str,
+    ):
+        """Initialize the remote auth provider.
+
+        Args:
+            token_verifier: TokenVerifier instance for token validation
+            authorization_servers: List of authorization servers that issue valid tokens
+            resource_server_url: URL of this resource server. This is used
+            for RFC 8707 resource indicators, including creating the WWW-Authenticate
+            header.
+        """
+        super().__init__(resource_server_url=resource_server_url)
+        self.token_verifier = token_verifier
+        self.authorization_servers = authorization_servers
+
+    async def verify_token(self, token: str) -> AccessToken | None:
+        """Verify token using the configured token verifier."""
+        return await self.token_verifier.verify_token(token)
+
+    def get_routes(self) -> list[Route]:
+        """Get OAuth routes for this provider.
+
+        By default, returns only the standardized OAuth 2.0 Protected Resource routes.
+        Subclasses can override this method to add additional routes by calling
+        super().get_routes() and extending the returned list.
+        """
+        assert self.resource_server_url is not None
+
+        return create_protected_resource_routes(
+            resource_url=self.resource_server_url,
+            authorization_servers=self.authorization_servers,
+            scopes_supported=self.token_verifier.required_scopes,
+        )
+
+
 class OAuthProvider(
     AuthProvider,
     OAuthAuthorizationServerProvider[AuthorizationCode, RefreshToken, AccessToken],
@@ -181,17 +246,33 @@ class OAuthProvider(
         """
         return await self.load_access_token(token)
 
-    def customize_auth_routes(self, routes: list[Route]) -> list[Route]:
-        """Customize OAuth authentication routes after standard creation.
+    def get_routes(self) -> list[Route]:
+        """Get OAuth authorization server routes and optional protected resource routes.
 
-        This method allows providers to modify the standard OAuth routes
-        returned by create_auth_routes. The default implementation returns
-        the routes unchanged.
-
-        Args:
-            routes: List of standard OAuth routes from create_auth_routes
+        This method creates the full set of OAuth routes including:
+        - Standard OAuth authorization server routes (/.well-known/oauth-authorization-server, /authorize, /token, etc.)
+        - Optional protected resource routes if resource_server_url is configured
 
         Returns:
-            List of routes (potentially modified)
+            List of OAuth routes
         """
-        return routes
+
+        # Create standard OAuth authorization server routes
+        oauth_routes = create_auth_routes(
+            provider=self,
+            issuer_url=self.issuer_url,
+            service_documentation_url=self.service_documentation_url,
+            client_registration_options=self.client_registration_options,
+            revocation_options=self.revocation_options,
+        )
+
+        # Add protected resource routes if this server is also acting as a resource server
+        if self.resource_server_url:
+            protected_routes = create_protected_resource_routes(
+                resource_url=self.resource_server_url,
+                authorization_servers=[self.issuer_url],
+                scopes_supported=self.required_scopes,
+            )
+            oauth_routes.extend(protected_routes)
+
+        return oauth_routes

fastmcp/server/auth/providers/jwt.py

@@ -16,7 +16,7 @@ from pydantic import AnyHttpUrl, SecretStr
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from typing_extensions import TypedDict
 
-from fastmcp.server.auth.auth import TokenVerifier
+from fastmcp.server.auth import TokenVerifier
 from fastmcp.server.auth.registry import register_provider
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.types import NotSet, NotSetT

fastmcp/server/auth/providers/workos.py

@@ -1,15 +1,12 @@
 from __future__ import annotations
 
 import httpx
-from mcp.server.auth.provider import (
-    AccessToken,
-)
 from pydantic import AnyHttpUrl
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from starlette.responses import JSONResponse
-from starlette.routing import BaseRoute, Route
+from starlette.routing import Route
 
-from fastmcp.server.auth.auth import AuthProvider, TokenVerifier
+from fastmcp.server.auth import RemoteAuthProvider, TokenVerifier
 from fastmcp.server.auth.providers.jwt import JWTVerifier
 from fastmcp.server.auth.registry import register_provider
 from fastmcp.utilities.logging import get_logger
@@ -31,10 +28,10 @@ class AuthKitProviderSettings(BaseSettings):
 
 
 @register_provider("AUTHKIT")
-class AuthKitProvider(AuthProvider):
-    """WorkOS AuthKit metadata provider for DCR (Dynamic Client Registration).
+class AuthKitProvider(RemoteAuthProvider):
+    """AuthKit metadata provider for DCR (Dynamic Client Registration).
 
-    This provider implements WorkOS AuthKit integration using metadata forwarding
+    This provider implements AuthKit integration using metadata forwarding
     instead of OAuth proxying. This is the recommended approach for WorkOS DCR
     as it allows WorkOS to handle the OAuth flow directly while FastMCP acts
     as a resource server.
@@ -56,7 +53,7 @@ class AuthKitProvider(AuthProvider):
         ```python
         from fastmcp.server.auth.providers.workos import AuthKitProvider
 
-        # Create WorkOS metadata provider (JWT verifier created automatically)
+        # Create AuthKit metadata provider (JWT verifier created automatically)
         workos_auth = AuthKitProvider(
             authkit_domain="https://your-workos-domain.authkit.app",
             base_url="https://your-fastmcp-server.com",
@@ -75,16 +72,14 @@ class AuthKitProvider(AuthProvider):
         required_scopes: list[str] | None | NotSetT = NotSet,
         token_verifier: TokenVerifier | None = None,
     ):
-        """Initialize WorkOS metadata provider.
+        """Initialize AuthKit metadata provider.
 
         Args:
-            authkit_domain: Your WorkOS AuthKit domain (e.g., "https://your-app.authkit.app")
+            authkit_domain: Your AuthKit domain (e.g., "https://your-app.authkit.app")
             base_url: Public URL of this FastMCP server
             required_scopes: Optional list of scopes to require for all requests
-            token_verifier: Optional token verifier. If None, creates JWT verifier for WorkOS
+            token_verifier: Optional token verifier. If None, creates JWT verifier for AuthKit
         """
-        super().__init__()
-
         settings = AuthKitProviderSettings.model_validate(
             {
                 k: v
@@ -109,19 +104,21 @@ class AuthKitProvider(AuthProvider):
                 required_scopes=settings.required_scopes,
             )
 
-        self.token_verifier = token_verifier
-
-    async def verify_token(self, token: str) -> AccessToken | None:
-        """Verify a WorkOS token using the configured token verifier."""
-        return await self.token_verifier.verify_token(token)
+        # Initialize RemoteAuthProvider with AuthKit as the authorization server
+        super().__init__(
+            token_verifier=token_verifier,
+            authorization_servers=[AnyHttpUrl(self.authkit_domain)],
+            resource_server_url=self.base_url,
+        )
 
-    def customize_auth_routes(self, routes: list[BaseRoute]) -> list[BaseRoute]:
-        """Add AuthKit metadata endpoints.
+    def get_routes(self) -> list[Route]:
+        """Get OAuth routes including AuthKit authorization server metadata forwarding.
 
-        This adds:
-        - /.well-known/oauth-authorization-server (forwards AuthKit metadata)
-        - /.well-known/oauth-protected-resource (returns FastMCP resource info)
+        This returns the standard protected resource routes plus an authorization server
+        metadata endpoint that forwards AuthKit's OAuth metadata to clients.
         """
+        # Get the standard protected resource routes from RemoteAuthProvider
+        routes = super().get_routes()
 
         async def oauth_authorization_server_metadata(request):
             """Forward AuthKit OAuth authorization server metadata with FastMCP customizations."""
@@ -142,29 +139,13 @@ class AuthKitProvider(AuthProvider):
                     status_code=500,
                 )
 
-        async def oauth_protected_resource_metadata(request):
-            """Return FastMCP resource server metadata."""
-            return JSONResponse(
-                {
-                    "resource": self.base_url,
-                    "authorization_servers": [self.authkit_domain],
-                    "bearer_methods_supported": ["header"],
-                }
+        # Add AuthKit authorization server metadata forwarding
+        routes.append(
+            Route(
+                "/.well-known/oauth-authorization-server",
+                endpoint=oauth_authorization_server_metadata,
+                methods=["GET"],
             )
-
-        routes.extend(
-            [
-                Route(
-                    "/.well-known/oauth-authorization-server",
-                    endpoint=oauth_authorization_server_metadata,
-                    methods=["GET"],
-                ),
-                Route(
-                    "/.well-known/oauth-protected-resource",
-                    endpoint=oauth_protected_resource_metadata,
-                    methods=["GET"],
-                ),
-            ]
         )
 
         return routes

fastmcp/server/http.py

@@ -11,12 +11,10 @@ from mcp.server.auth.middleware.bearer_auth import (
     RequireAuthMiddleware,
 )
 from mcp.server.auth.provider import TokenVerifier as TokenVerifierProtocol
-from mcp.server.auth.routes import create_auth_routes
 from mcp.server.lowlevel.server import LifespanResultT
 from mcp.server.sse import SseServerTransport
 from mcp.server.streamable_http import EventStore
 from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
-from pydantic import AnyHttpUrl
 from starlette.applications import Starlette
 from starlette.middleware import Middleware
 from starlette.middleware.authentication import AuthenticationMiddleware
@@ -25,7 +23,7 @@ from starlette.responses import Response
 from starlette.routing import BaseRoute, Mount, Route
 from starlette.types import Lifespan, Receive, Scope, Send
 
-from fastmcp.server.auth.auth import AuthProvider, OAuthProvider, TokenVerifier
+from fastmcp.server.auth.auth import AuthProvider
 from fastmcp.utilities.logging import get_logger
 
 if TYPE_CHECKING:
@@ -71,51 +69,6 @@ class RequestContextMiddleware:
             await self.app(scope, receive, send)
 
 
-def setup_auth_middleware_and_routes(
-    auth: AuthProvider,
-) -> tuple[list[Middleware], list[Route], list[str]]:
-    """Set up authentication middleware and routes if auth is enabled.
-
-    Args:
-        auth: An AuthProvider for authentication (TokenVerifier or OAuthProvider)
-
-    Returns:
-        Tuple of (middleware, auth_routes, required_scopes)
-    """
-    middleware: list[Middleware] = [
-        Middleware(
-            AuthenticationMiddleware,
-            backend=BearerAuthBackend(cast(TokenVerifierProtocol, auth)),
-        ),
-        Middleware(AuthContextMiddleware),
-    ]
-
-    auth_routes: list[Route] = []
-    required_scopes: list[str] = auth.required_scopes or []
-
-    # Check if it's an OAuthProvider (has OAuth server capability)
-    if isinstance(auth, OAuthProvider):
-        # OAuthProvider: create standard OAuth routes first
-        standard_routes = list(
-            create_auth_routes(
-                provider=auth,
-                issuer_url=auth.issuer_url,
-                service_documentation_url=auth.service_documentation_url,
-                client_registration_options=auth.client_registration_options,
-                revocation_options=auth.revocation_options,
-            )
-        )
-
-        # Allow provider to customize routes (e.g., for proxy behavior or metadata endpoints)
-        auth_routes = auth.customize_auth_routes(standard_routes)
-    else:
-        # Simple AuthProvider or TokenVerifier: start with empty routes
-        # Allow provider to add custom routes (e.g., metadata endpoints)
-        auth_routes = auth.customize_auth_routes([])
-
-    return middleware, auth_routes, required_scopes
-
-
 def create_base_app(
     routes: list[BaseRoute],
     middleware: list[Middleware],
@@ -183,24 +136,27 @@ def create_sse_app(
             )
         return Response()
 
-    # Get auth middleware and routes
+    # Set up auth if enabled
     if auth:
-        auth_middleware, auth_routes, required_scopes = (
-            setup_auth_middleware_and_routes(auth)
-        )
+        # Create auth middleware
+        auth_middleware = [
+            Middleware(
+                AuthenticationMiddleware,
+                backend=BearerAuthBackend(auth),
+            ),
+            Middleware(AuthContextMiddleware),
+        ]
+
+        # Get auth routes and scopes
+        auth_routes = auth.get_routes()
+        required_scopes = getattr(auth, "required_scopes", None) or []
+
+        # Get resource metadata URL for WWW-Authenticate header
+        resource_metadata_url = auth.get_resource_metadata_url()
 
         server_routes.extend(auth_routes)
         server_middleware.extend(auth_middleware)
 
-        # Determine resource_metadata_url for TokenVerifier
-        resource_metadata_url = None
-        if isinstance(auth, TokenVerifier) and auth.resource_server_url:
-            # Add .well-known path for RFC 9728 compliance
-            resource_metadata_url = AnyHttpUrl(
-                str(auth.resource_server_url).rstrip("/")
-                + "/.well-known/oauth-protected-resource"
-            )
-
         # Auth is enabled, wrap endpoints with RequireAuthMiddleware
         server_routes.append(
             Route(
@@ -328,22 +284,25 @@ def create_streamable_http_app(
 
     # Add StreamableHTTP routes with or without auth
     if auth:
-        auth_middleware, auth_routes, required_scopes = (
-            setup_auth_middleware_and_routes(auth)
-        )
+        # Create auth middleware
+        auth_middleware = [
+            Middleware(
+                AuthenticationMiddleware,
+                backend=BearerAuthBackend(cast(TokenVerifierProtocol, auth)),
+            ),
+            Middleware(AuthContextMiddleware),
+        ]
+
+        # Get auth routes and scopes
+        auth_routes = auth.get_routes()
+        required_scopes = getattr(auth, "required_scopes", None) or []
+
+        # Get resource metadata URL for WWW-Authenticate header
+        resource_metadata_url = auth.get_resource_metadata_url()
 
         server_routes.extend(auth_routes)
         server_middleware.extend(auth_middleware)
 
-        # Determine resource_metadata_url for TokenVerifier
-        resource_metadata_url = None
-        if isinstance(auth, TokenVerifier) and auth.resource_server_url:
-            # Add .well-known path for RFC 9728 compliance
-            resource_metadata_url = AnyHttpUrl(
-                str(auth.resource_server_url).rstrip("/")
-                + "/.well-known/oauth-protected-resource"
-            )
-
         # Auth is enabled, wrap endpoint with RequireAuthMiddleware
         server_routes.append(
             Mount(

fastmcp/server/proxy.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+import inspect
 import warnings
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 from urllib.parse import quote
@@ -48,11 +49,27 @@ if TYPE_CHECKING:
 
 logger = get_logger(__name__)
 
+# Type alias for client factory functions
+ClientFactoryT = Callable[[], Client] | Callable[[], Awaitable[Client]]
 
-class ProxyToolManager(ToolManager):
+
+class ProxyManagerMixin:
+    """A mixin for proxy managers to provide a unified client retrieval method."""
+
+    client_factory: ClientFactoryT
+
+    async def _get_client(self) -> Client:
+        """Gets a client instance by calling the sync or async factory."""
+        client = self.client_factory()
+        if inspect.isawaitable(client):
+            client = await client
+        return client
+
+
+class ProxyToolManager(ToolManager, ProxyManagerMixin):
     """A ToolManager that sources its tools from a remote client in addition to local and mounted tools."""
 
-    def __init__(self, client_factory: Callable[[], Client], **kwargs):
+    def __init__(self, client_factory: ClientFactoryT, **kwargs):
         super().__init__(**kwargs)
         self.client_factory = client_factory
 
@@ -63,7 +80,7 @@ class ProxyToolManager(ToolManager):
 
         # Then add proxy tools, but don't overwrite existing ones
         try:
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 client_tools = await client.list_tools()
                 for tool in client_tools:
@@ -94,7 +111,7 @@ class ProxyToolManager(ToolManager):
             return await super().call_tool(key, arguments)
         except NotFoundError:
             # If not found locally, try proxy
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 result = await client.call_tool(key, arguments)
                 return ToolResult(
@@ -103,10 +120,10 @@ class ProxyToolManager(ToolManager):
                 )
 
 
-class ProxyResourceManager(ResourceManager):
+class ProxyResourceManager(ResourceManager, ProxyManagerMixin):
     """A ResourceManager that sources its resources from a remote client in addition to local and mounted resources."""
 
-    def __init__(self, client_factory: Callable[[], Client], **kwargs):
+    def __init__(self, client_factory: ClientFactoryT, **kwargs):
         super().__init__(**kwargs)
         self.client_factory = client_factory
 
@@ -117,7 +134,7 @@ class ProxyResourceManager(ResourceManager):
 
         # Then add proxy resources, but don't overwrite existing ones
         try:
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 client_resources = await client.list_resources()
                 for resource in client_resources:
@@ -140,7 +157,7 @@ class ProxyResourceManager(ResourceManager):
 
         # Then add proxy templates, but don't overwrite existing ones
         try:
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 client_templates = await client.list_resource_templates()
                 for template in client_templates:
@@ -173,7 +190,7 @@ class ProxyResourceManager(ResourceManager):
             return await super().read_resource(uri)
         except NotFoundError:
             # If not found locally, try proxy
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 result = await client.read_resource(uri)
                 if isinstance(result[0], TextResourceContents):
@@ -184,10 +201,10 @@ class ProxyResourceManager(ResourceManager):
                     raise ResourceError(f"Unsupported content type: {type(result[0])}")
 
 
-class ProxyPromptManager(PromptManager):
+class ProxyPromptManager(PromptManager, ProxyManagerMixin):
     """A PromptManager that sources its prompts from a remote client in addition to local and mounted prompts."""
 
-    def __init__(self, client_factory: Callable[[], Client], **kwargs):
+    def __init__(self, client_factory: ClientFactoryT, **kwargs):
         super().__init__(**kwargs)
         self.client_factory = client_factory
 
@@ -198,7 +215,7 @@ class ProxyPromptManager(PromptManager):
 
         # Then add proxy prompts, but don't overwrite existing ones
         try:
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 client_prompts = await client.list_prompts()
                 for prompt in client_prompts:
@@ -230,7 +247,7 @@ class ProxyPromptManager(PromptManager):
             return await super().render_prompt(name, arguments)
         except NotFoundError:
             # If not found locally, try proxy
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 result = await client.get_prompt(name, arguments)
                 return result
@@ -444,7 +461,7 @@ class FastMCPProxy(FastMCP):
         self,
         client: Client | None = None,
         *,
-        client_factory: Callable[[], Client] | None = None,
+        client_factory: ClientFactoryT | None = None,
         **kwargs,
     ):
         """
@@ -459,6 +476,7 @@ class FastMCPProxy(FastMCP):
                    created that provides session isolation for backwards compatibility.
             client_factory: A callable that returns a Client instance when called.
                            This gives you full control over session creation and reuse.
+                           Can be either a synchronous or asynchronous function.
             **kwargs: Additional settings for the FastMCP server.
         """
 

fastmcp/server/server.py

@@ -140,19 +140,18 @@ class FastMCP(Generic[LifespanResultT]):
             ]
             | None
         ) = None,
-        tool_serializer: Callable[[Any], str] | None = None,
-        cache_expiration_seconds: float | None = None,
-        on_duplicate_tools: DuplicateBehavior | None = None,
-        on_duplicate_resources: DuplicateBehavior | None = None,
-        on_duplicate_prompts: DuplicateBehavior | None = None,
+        dependencies: list[str] | None = None,
         resource_prefix_format: Literal["protocol", "path"] | None = None,
         mask_error_details: bool | None = None,
         tools: list[Tool | Callable[..., Any]] | None = None,
         tool_transformations: dict[str, ToolTransformConfig] | None = None,
-        dependencies: list[str] | None = None,
+        tool_serializer: Callable[[Any], str] | None = None,
         include_tags: set[str] | None = None,
         exclude_tags: set[str] | None = None,
         include_fastmcp_meta: bool | None = None,
+        on_duplicate_tools: DuplicateBehavior | None = None,
+        on_duplicate_resources: DuplicateBehavior | None = None,
+        on_duplicate_prompts: DuplicateBehavior | None = None,
         # ---
         # ---
         # --- The following arguments are DEPRECATED ---
@@ -304,6 +303,10 @@ class FastMCP(Generic[LifespanResultT]):
     def instructions(self) -> str | None:
         return self._mcp_server.instructions
 
+    @property
+    def version(self) -> str | None:
+        return self._mcp_server.version
+
     async def run_async(
         self,
         transport: Transport | None = None,

fastmcp/settings.py

@@ -244,13 +244,10 @@ class Settings(BaseSettings):
         ),
     ] = False
 
-    server_dependencies: Annotated[
-        list[str],
-        Field(
-            default_factory=list,
-            description="List of dependencies to install in the server environment",
-        ),
-    ] = []
+    server_dependencies: list[str] = Field(
+        default_factory=list,
+        description="List of dependencies to install in the server environment",
+    )
 
     # StreamableHTTP settings
     json_response: bool = False

fastmcp/utilities/components.py

@@ -92,7 +92,12 @@ class FastMCPComponent(FastMCPBaseModel):
         return meta or None
 
     def with_key(self, key: str) -> Self:
-        return self.model_copy(update={"_key": key})
+        # `model_copy` has an `update` parameter but it doesn't work for certain private attributes
+        # https://github.com/pydantic/pydantic/issues/12116
+        # So we manually set the private attribute here instead
+        copy = self.model_copy()
+        copy._key = key
+        return copy
 
     def __eq__(self, other: object) -> bool:
         if type(self) is not type(other):

fastmcp/utilities/inspect.py

@@ -9,6 +9,7 @@ from typing import Any
 from mcp.server.fastmcp import FastMCP as FastMCP1x
 
 import fastmcp
+from fastmcp import Client
 from fastmcp.server.server import FastMCP
 
 
@@ -71,7 +72,7 @@ class FastMCPInfo:
     instructions: str | None
     fastmcp_version: str
     mcp_version: str
-    server_version: str
+    server_version: str | None
     tools: list[ToolInfo]
     prompts: list[PromptInfo]
     resources: list[ResourceInfo]
@@ -170,7 +171,9 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
         instructions=mcp.instructions,
         fastmcp_version=fastmcp.__version__,
         mcp_version=importlib.metadata.version("mcp"),
-        server_version=fastmcp.__version__,  # v2.x uses FastMCP version
+        server_version=(
+            mcp.version if hasattr(mcp, "version") else mcp._mcp_server.version
+        ),
         tools=tool_infos,
         prompts=prompt_infos,
         resources=resource_infos,
@@ -179,7 +182,7 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
     )
 
 
-async def inspect_fastmcp_v1(mcp: Any) -> FastMCPInfo:
+async def inspect_fastmcp_v1(mcp: FastMCP1x) -> FastMCPInfo:
     """Extract information from a FastMCP v1.x instance using a Client.
 
     Args:
@@ -188,7 +191,6 @@ async def inspect_fastmcp_v1(mcp: Any) -> FastMCPInfo:
     Returns:
         FastMCPInfo dataclass containing the extracted information
     """
-    from fastmcp import Client
 
     # Use a client to interact with the FastMCP1x server
     async with Client(mcp) as client:
@@ -288,11 +290,11 @@ async def inspect_fastmcp_v1(mcp: Any) -> FastMCPInfo:
         }
 
         return FastMCPInfo(
-            name=mcp.name,
-            instructions=getattr(mcp, "instructions", None),
-            fastmcp_version=fastmcp.__version__,  # Report current fastmcp version
+            name=mcp._mcp_server.name,
+            instructions=mcp._mcp_server.instructions,
+            fastmcp_version=importlib.metadata.version("mcp"),
             mcp_version=importlib.metadata.version("mcp"),
-            server_version="1.0",  # FastMCP 1.x version
+            server_version=mcp._mcp_server.version,
             tools=tool_infos,
             prompts=prompt_infos,
             resources=resource_infos,
@@ -301,14 +303,7 @@ async def inspect_fastmcp_v1(mcp: Any) -> FastMCPInfo:
         )
 
 
-def _is_fastmcp_v1(mcp: Any) -> bool:
-    """Check if the given instance is a FastMCP v1.x instance."""
-
-    # Check if it's an instance of FastMCP1x and not FastMCP2
-    return isinstance(mcp, FastMCP1x) and not isinstance(mcp, FastMCP)
-
-
-async def inspect_fastmcp(mcp: FastMCP[Any] | Any) -> FastMCPInfo:
+async def inspect_fastmcp(mcp: FastMCP[Any] | FastMCP1x) -> FastMCPInfo:
     """Extract information from a FastMCP instance into a dataclass.
 
     This function automatically detects whether the instance is FastMCP v1.x or v2.x
@@ -320,7 +315,7 @@ async def inspect_fastmcp(mcp: FastMCP[Any] | Any) -> FastMCPInfo:
     Returns:
         FastMCPInfo dataclass containing the extracted information
     """
-    if _is_fastmcp_v1(mcp):
+    if isinstance(mcp, FastMCP1x):
         return await inspect_fastmcp_v1(mcp)
     else:
         return await inspect_fastmcp_v2(mcp)

fastmcp/utilities/openapi.py

@@ -82,13 +82,9 @@ def format_array_parameter(
             return values
         else:
             # For path parameters, fallback to string representation without Python syntax
-            str_value = (
-                str(values)
-                .replace("[", "")
-                .replace("]", "")
-                .replace("'", "")
-                .replace('"', "")
-            )
+            # Use str.translate() for efficient character removal
+            translation_table = str.maketrans("", "", "[]'\"")
+            str_value = str(values).translate(translation_table)
             return str_value
 
 

fastmcp/utilities/types.py

@@ -101,7 +101,12 @@ def get_cached_typeadapter(cls: T) -> TypeAdapter[T]:
                 new_func.__module__ = cls.__module__
                 new_func.__qualname__ = getattr(cls, "__qualname__", cls.__name__)
                 new_func.__annotations__ = processed_hints
-                return TypeAdapter(new_func)
+
+                if inspect.ismethod(cls):
+                    new_method = types.MethodType(new_func, cls.__self__)
+                    return TypeAdapter(new_method)
+                else:
+                    return TypeAdapter(new_func)
 
     return TypeAdapter(cls)
 

{fastmcp-2.11.0.dist-info → fastmcp-2.11.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.11.0
+Version: 2.11.2
 Summary: The fast, Pythonic way to build MCP servers and clients.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp

{fastmcp-2.11.0.dist-info → fastmcp-2.11.2.dist-info}/RECORD

@@ -2,17 +2,17 @@ fastmcp/__init__.py,sha256=B_FAqsxbTJmwvJKyIDMOZWpUUdmO806bKo8RR32oZL0,1503
 fastmcp/exceptions.py,sha256=-krEavxwddQau6T7MESCR4VjKNLfP9KHJrU1p3y72FU,744
 fastmcp/mcp_config.py,sha256=jf6VyGHli3GcZNg4spdV1L_lPOeNCKTJh-nGIBaMgn4,10324
 fastmcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastmcp/settings.py,sha256=70cxWrYktvHSOHCgj2rKLJ09HU-pHnfs0jCxxv2Rf80,11131
+fastmcp/settings.py,sha256=LxSDlUmWX2SJLZRjX5ih07jAVIHaFZFRK7RCQPPKAGI,11081
 fastmcp/cli/__init__.py,sha256=Ii284TNoG5lxTP40ETMGhHEq3lQZWxu9m9JuU57kUpQ,87
 fastmcp/cli/claude.py,sha256=IAlcZ4qZKBBj09jZUMEx7EANZE_IR3vcu7zOBJmMOuU,4567
-fastmcp/cli/cli.py,sha256=ovUWG-E3lAfIfKegn2zfYM9oiB0yyPkLViQZd12mYKw,15669
-fastmcp/cli/run.py,sha256=OOdau2sNQsgan4NXucY-3LWOWn6cKjmdALfzht2RXQ0,10508
+fastmcp/cli/cli.py,sha256=32OKZ49JKq3INqIlHXnZfFNTxQ2XYE1UkW3x5iTvtlI,15699
+fastmcp/cli/run.py,sha256=12I_JP4NSbmNqfQT2u14wvl4Uq2Rr_RvlK1z6bgAfOQ,12383
 fastmcp/cli/install/__init__.py,sha256=cDEc0hhuf_xwGpI6ghpqlvlMdBMJUGHq_rs-tgmOJZ8,695
-fastmcp/cli/install/claude_code.py,sha256=ayTZtudjNWHE8MIGeJfb_TmJI3F5K_DHD1X3qEjxEWg,7712
-fastmcp/cli/install/claude_desktop.py,sha256=y8ha2OKM8IuvQbmGNq842q-m-vs_ts2P9cMxAhbBvs4,6872
-fastmcp/cli/install/cursor.py,sha256=q5jXBzpxvoWrgP9pItwNlyl13XpYbtIlZS_dRBkBSdc,6837
-fastmcp/cli/install/mcp_json.py,sha256=uxCN8fsIjJStWtL0J7kfQ9haIJU0SYF8CXYT-crl_o0,5923
-fastmcp/cli/install/shared.py,sha256=Y0YZei1YemVCkg0ieUgfRse-lqSlIn5Ho8t6pB9nDa4,2683
+fastmcp/cli/install/claude_code.py,sha256=1aSO02cJGGWAVl_iVY_dWpShz9Df5ndrAGA_qEj5rbc,7724
+fastmcp/cli/install/claude_desktop.py,sha256=4ErROs-wxdLWr-bCMvL3r9-UIYMETfAghzHTNzhLx5E,6884
+fastmcp/cli/install/cursor.py,sha256=KkRzIBiqaJhmT1wfl3IzprgTnIiAIioTcveq-oDHELE,6849
+fastmcp/cli/install/mcp_json.py,sha256=RUlg7rQiwBysgTOoJfjvVwgz9MFXT-u7aleBDzK1eVQ,5935
+fastmcp/cli/install/shared.py,sha256=T-0R3-WMlmq5uRHYMEVbdItvm6zThzFET4AlI_foG7s,2695
 fastmcp/client/__init__.py,sha256=J-RcLU2WcnYnstXWoW01itGtAg7DEjvCsWyqQKQljoo,663
 fastmcp/client/client.py,sha256=GniETS28L8B-ahzztU2ZLI_XSCcEib-miGzE2ZnG4Xc,34054
 fastmcp/client/elicitation.py,sha256=Jf9yqna8R7r1hqedXAyh9a2-QNVzbCSKUDZhkFHqHqg,2403
@@ -65,19 +65,19 @@ fastmcp/server/__init__.py,sha256=bMD4aQD4yJqLz7-mudoNsyeV8UgQfRAg3PRwPvwTEds,11
 fastmcp/server/context.py,sha256=ooVwF4RoIbLB2S043E5HtK_dCyAWQkDm1YWCkqfUPzs,22638
 fastmcp/server/dependencies.py,sha256=gfb1l3KD2m3h7BpN8lgKWrHY3_OJdDrlnJXCvzmU5YM,2487
 fastmcp/server/elicitation.py,sha256=jZIHjV4NjhYbT-w8pBArwd0vNzP8OYwzmsnWDdk6Bd0,6136
-fastmcp/server/http.py,sha256=aFWWPB_l9HPFnqTh_RMdrDGFMUETGkiQIeXqSzf7ZoA,13396
+fastmcp/server/http.py,sha256=idZGs4kRm_eLMscMrlEBIBpX21aiuTlvon9Fizmjswo,11648
 fastmcp/server/low_level.py,sha256=LNmc_nU_wx-fRG8OEHdLPKopZpovcrWlyAxJzKss3TA,1239
 fastmcp/server/openapi.py,sha256=-7-pKwQ1hT-UV9OnLlWrjbbXXRfZld8YJqa4Duybhtw,42102
-fastmcp/server/proxy.py,sha256=4eHW2Vgwe7zvd0g-ozsvYRyIoengyGyhlyMcSPhcaIU,24975
-fastmcp/server/server.py,sha256=hmNiwYFnWhERY-WhxAvS9jIvXOx8_g8ylX-Ju91Y4qk,87597
-fastmcp/server/auth/__init__.py,sha256=_9t3pctON0W55jLFTZp06oS6BLiRUQhmX5LgtA-ya48,504
-fastmcp/server/auth/auth.py,sha256=TZ_XBJ66gR5vb4BdIpe-EkUa1pRR03AA-oZj-YiAtsA,7035
+fastmcp/server/proxy.py,sha256=soKobVa-c-1Vex7IYnz-jAT526Do2Z4Rs1FaT5ruLro,25651
+fastmcp/server/server.py,sha256=PBDHMx2N2Zr6qVeEs7XEcZrCNObnsAoIrPbK9DlArGk,87634
+fastmcp/server/auth/__init__.py,sha256=ldv13Dsxr2r-VdUV6af6P5qa3wMPQ-MP_yKxsWdlb-4,550
+fastmcp/server/auth/auth.py,sha256=FMkCcht4BMEqKx-SwvfzVC5l7X2moiIzS_ZevaHBq08,10536
 fastmcp/server/auth/registry.py,sha256=4ftVbbuyAi-8zBiJL9-dYIKLU_EOpxY-pFdzHMrmjV8,1306
 fastmcp/server/auth/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastmcp/server/auth/providers/bearer.py,sha256=iu4pUj7TF5pT1wPuAGzDuM6lt5WtzenBN3c0otUleQY,923
 fastmcp/server/auth/providers/in_memory.py,sha256=tlUwbUZK5stUC_wjezcDs61PxjaHjykXbd8aH0cnW6k,14359
-fastmcp/server/auth/providers/jwt.py,sha256=oHwtnQ8hUBwV9ZZZsCBNCj9s4yUYUaweULQYl6MMHgk,18887
-fastmcp/server/auth/providers/workos.py,sha256=fIMmTFJpX6QyYsetxtPO87QJH8Aom9UmHSgedo0DMY4,6131
+fastmcp/server/auth/providers/jwt.py,sha256=7pAH8kuudl_lbY2skeVDlLkxFMhs5-3axpAoGVVp_MU,18882
+fastmcp/server/auth/providers/workos.py,sha256=jedSq4uhttDxYDYSZFrb4u_q1X9JeHgvKupJPpu0tSM,5590
 fastmcp/server/middleware/__init__.py,sha256=vh5C9ubN6q-y5QND32P4mQ4zDT89C7XYK39yqhELNAk,155
 fastmcp/server/middleware/error_handling.py,sha256=SoDatr9i3T2qSIUbSEGWrOnu4WPPyMDymnsF5GR_BiE,7572
 fastmcp/server/middleware/logging.py,sha256=UIAoafnKRGWpQa7OX5nzChep-9EhKdyTDBmmcRcEVdo,6239
@@ -90,19 +90,19 @@ fastmcp/tools/tool_manager.py,sha256=Pr6BI7IInvhkTw2S4ENWj8qMewdYi2CpzbOBiJIk40c
 fastmcp/tools/tool_transform.py,sha256=f8Bt79qdmOM8Zietm7lXb5_5DlJLu02ovGmQBQJ6orw,36671
 fastmcp/utilities/__init__.py,sha256=-imJ8S-rXmbXMWeDamldP-dHDqAPg_wwmPVz-LNX14E,31
 fastmcp/utilities/cli.py,sha256=TXuSyALFAGJwi7tWEBwBmaGhYZBdF1aG6dLgl3zjM1w,3272
-fastmcp/utilities/components.py,sha256=WbmAn925ESRsMc4jm3gNQghvAkfeCjSXquOxU4ENZc4,5085
+fastmcp/utilities/components.py,sha256=wmo1XZBqf_tcOMMN1a-r8d1pT7g--Zmf75f5-vXx5FA,5333
 fastmcp/utilities/exceptions.py,sha256=7Z9j5IzM5rT27BC1Mcn8tkS-bjqCYqMKwb2MMTaxJYU,1350
 fastmcp/utilities/http.py,sha256=1ns1ymBS-WSxbZjGP6JYjSO52Wa_ls4j4WbnXiupoa4,245
-fastmcp/utilities/inspect.py,sha256=XNA0dfYM5G-FVbJaVJO8loSUUCNypyLA-QjqTOneJyU,10833
+fastmcp/utilities/inspect.py,sha256=VLCrh8oMnIg49uuwVO899rUcHhxszPJ1nU0RZ8q2HX8,10639
 fastmcp/utilities/json_schema.py,sha256=Nk6qQKtp0-MlMbRQmx8ps8SJ7SW9CpuWhSes1VASFPQ,8141
 fastmcp/utilities/json_schema_type.py,sha256=fSG-af3OPGgOhuhY_xb0-JsTu5tqi275zXlUw4ItjNo,22287
 fastmcp/utilities/logging.py,sha256=1y7oNmy8WrR0NsfNVw1LPoKu92OFdmzIO65syOKi_BI,1388
 fastmcp/utilities/mcp_config.py,sha256=zzs4VWHqG0eWEnEUwVve7mef_JFThwfvqBYt7nx3jXc,871
-fastmcp/utilities/openapi.py,sha256=URb_OG3D1HQ2KW38rqeyy_fHzpthf-RYlGhDm_7KDjE,63310
+fastmcp/utilities/openapi.py,sha256=Jcxu0s9VdA8RSkx1iyoTQwvsny4YCusuuJahyy-TvE8,63300
 fastmcp/utilities/tests.py,sha256=9FVLmGYfUjqfn0pPH33awlTgvg-JCNbnZnraJHNSYTg,6156
-fastmcp/utilities/types.py,sha256=JmIgOGlFDf3Ksde9p22M8S60AlO6YJywNGtLeQMwwyo,13790
-fastmcp-2.11.0.dist-info/METADATA,sha256=azUYPj5I8ygluPs1Ix-pCrHi7NjCLF50twldOVe1eE4,17839
-fastmcp-2.11.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastmcp-2.11.0.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
-fastmcp-2.11.0.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fastmcp-2.11.0.dist-info/RECORD,,
+fastmcp/utilities/types.py,sha256=zrF8Oc_L_BdzGj0pqU5ZalM02BisC0_D-d8kcRGccS0,13984
+fastmcp-2.11.2.dist-info/METADATA,sha256=6OE28R9_gx-82MA3st0SR6dCxsfoH4oftu0jhSjbL10,17839
+fastmcp-2.11.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fastmcp-2.11.2.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
+fastmcp-2.11.2.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fastmcp-2.11.2.dist-info/RECORD,,