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

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/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/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.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.11.0
+Version: 2.11.1
 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.1.dist-info}/RECORD

@@ -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/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,7 +90,7 @@ 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
@@ -98,11 +98,11 @@ fastmcp/utilities/json_schema.py,sha256=Nk6qQKtp0-MlMbRQmx8ps8SJ7SW9CpuWhSes1VAS
 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.1.dist-info/METADATA,sha256=7kstQeYl88_tx9oEhjN98bGmGWskG478FOFlvfCuMiA,17839
+fastmcp-2.11.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fastmcp-2.11.1.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
+fastmcp-2.11.1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fastmcp-2.11.1.dist-info/RECORD,,