Merge branch 'main' into feature/exclude-args-support

docs/servers/fastmcp.mdx

@@ -35,6 +35,7 @@ The `FastMCP` constructor accepts several arguments:
 *   `instructions`: (Optional) Description of how to interact with this server. These instructions help clients understand the server's purpose and available functionality.
 *   `lifespan`: (Optional) An async context manager function for server startup and shutdown logic.
 *   `tags`: (Optional) A set of strings to tag the server itself.
+*   `tools`: (Optional) A list of tools (or functions to convert to tools) to add to the server. In some cases, providing tools programmatically may be more convenient than using the `@mcp.tool` decorator.
 *   `**settings`: Keyword arguments corresponding to additional `ServerSettings` configuration
 
 ## Components

pyproject.toml

@@ -7,11 +7,12 @@ dependencies = [
     "python-dotenv>=1.1.0",
     "exceptiongroup>=1.2.2",
     "httpx>=0.28.1",
-    "mcp>=1.9.0,<2.0.0",
+    "mcp>=1.9.2,<2.0.0",
     "openapi-pydantic>=0.5.1",
     "rich>=13.9.4",
     "typer>=0.15.2",
     "websockets>=14.0",
+    "authlib>=1.5.2",
 ]
 requires-python = ">=3.10"
 readme = "README.md"
@@ -44,12 +45,14 @@ dev = [
     "ipython>=8.12.3",
     "pdbpp>=0.10.3",
     "pre-commit",
+    "pyinstrument>=5.0.2",
     "pyright>=1.1.389",
     "pytest>=8.3.3",
     "pytest-asyncio>=0.23.5",
     "pytest-cov>=6.1.1",
     "pytest-env>=1.1.5",
     "pytest-flakefinder",
+    "pytest-httpx>=0.35.0",
     "pytest-report>=0.2.1",
     "pytest-timeout>=2.4.0",
     "pytest-xdist>=3.6.1",

src/fastmcp/client/__init__.py

@@ -11,6 +11,7 @@ from .transports import (
     FastMCPTransport,
     StreamableHttpTransport,
 )
+from .auth import OAuth
 
 __all__ = [
     "Client",
@@ -24,4 +25,5 @@ __all__ = [
     "NpxStdioTransport",
     "FastMCPTransport",
     "StreamableHttpTransport",
+    "OAuth",
 ]

src/fastmcp/client/auth.py

@@ -0,0 +1,403 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import webbrowser
+from pathlib import Path
+from typing import Any, Literal
+from urllib.parse import urljoin, urlparse
+
+import anyio
+import httpx
+from mcp.client.auth import OAuthClientProvider as _MCPOAuthClientProvider
+from mcp.client.auth import TokenStorage
+from mcp.shared.auth import (
+    OAuthClientInformationFull,
+    OAuthClientMetadata,
+)
+from mcp.shared.auth import (
+    OAuthMetadata as _MCPServerOAuthMetadata,
+)
+from mcp.shared.auth import (
+    OAuthToken as OAuthToken,
+)
+from pydantic import AnyHttpUrl, ValidationError
+
+from fastmcp.client.oauth_callback import (
+    create_oauth_callback_server,
+)
+from fastmcp.settings import settings as fastmcp_global_settings
+from fastmcp.utilities.http import find_available_port
+from fastmcp.utilities.logging import get_logger
+
+__all__ = ["OAuth"]
+
+logger = get_logger(__name__)
+
+
+def default_cache_dir() -> Path:
+    return fastmcp_global_settings.home / "oauth-mcp-client-cache"
+
+
+# Flexible OAuth models for real-world compatibility
+class ServerOAuthMetadata(_MCPServerOAuthMetadata):
+    """
+    More flexible OAuth metadata model that accepts broader ranges of values
+    than the restrictive MCP standard model.
+
+    This handles real-world OAuth servers like PayPal that may support
+    additional methods not in the MCP specification.
+    """
+
+    # Allow any code challenge methods, not just S256
+    code_challenge_methods_supported: list[str] | None = None
+
+    # Allow any token endpoint auth methods
+    token_endpoint_auth_methods_supported: list[str] | None = None
+
+    # Allow any grant types
+    grant_types_supported: list[str] | None = None
+
+    # Allow any response types
+    response_types_supported: list[str] = ["code"]
+
+    # Allow any response modes
+    response_modes_supported: list[str] | None = None
+
+
+class OAuthClientProvider(_MCPOAuthClientProvider):
+    """
+    OAuth client provider with more flexible OAuth metadata discovery.
+
+    This subclass handles real-world OAuth servers that may not conform
+    strictly to the MCP OAuth specification but are still valid OAuth 2.0 servers.
+    """
+
+    async def _discover_oauth_metadata(
+        self, server_url: str
+    ) -> ServerOAuthMetadata | None:
+        """
+        Discover OAuth metadata with flexible validation.
+
+        This is nearly identical to the parent implementation but uses
+        ServerOAuthMetadata instead of the restrictive MCP OAuthMetadata.
+        """
+        # Extract base URL per MCP spec
+        auth_base_url = self._get_authorization_base_url(server_url)
+        url = urljoin(auth_base_url, "/.well-known/oauth-authorization-server")
+
+        from mcp.types import LATEST_PROTOCOL_VERSION
+
+        headers = {"MCP-Protocol-Version": LATEST_PROTOCOL_VERSION}
+
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(url, headers=headers)
+                if response.status_code == 404:
+                    return None
+                response.raise_for_status()
+                metadata_json = response.json()
+                logger.debug(f"OAuth metadata discovered: {metadata_json}")
+                return ServerOAuthMetadata.model_validate(metadata_json)
+            except Exception:
+                # Retry without MCP header for CORS compatibility
+                try:
+                    response = await client.get(url)
+                    if response.status_code == 404:
+                        return None
+                    response.raise_for_status()
+                    metadata_json = response.json()
+                    logger.debug(
+                        f"OAuth metadata discovered (no MCP header): {metadata_json}"
+                    )
+                    return ServerOAuthMetadata.model_validate(metadata_json)
+                except Exception:
+                    logger.exception("Failed to discover OAuth metadata")
+                    return None
+
+
+class FileTokenStorage(TokenStorage):
+    """
+    File-based token storage implementation for OAuth credentials and tokens.
+    Implements the mcp.client.auth.TokenStorage protocol.
+
+    Each instance is tied to a specific server URL for proper token isolation.
+    """
+
+    def __init__(self, server_url: str, cache_dir: Path | None = None):
+        """Initialize storage for a specific server URL."""
+        self.server_url = server_url
+        self.cache_dir = cache_dir or default_cache_dir()
+        self.cache_dir.mkdir(exist_ok=True, parents=True)
+
+    @staticmethod
+    def get_base_url(url: str) -> str:
+        """Extract the base URL (scheme + host) from a URL."""
+        parsed = urlparse(url)
+        return f"{parsed.scheme}://{parsed.netloc}"
+
+    def get_cache_key(self) -> str:
+        """Generate a safe filesystem key from the server's base URL."""
+        base_url = self.get_base_url(self.server_url)
+        return (
+            base_url.replace("://", "_")
+            .replace(".", "_")
+            .replace("/", "_")
+            .replace(":", "_")
+        )
+
+    def _get_file_path(self, file_type: Literal["client_info", "tokens"]) -> Path:
+        """Get the file path for the specified cache file type."""
+        key = self.get_cache_key()
+        return self.cache_dir / f"{key}_{file_type}.json"
+
+    async def get_tokens(self) -> OAuthToken | None:
+        """Load tokens from file storage."""
+        path = self._get_file_path("tokens")
+
+        try:
+            tokens = OAuthToken.model_validate_json(path.read_text())
+            # now = datetime.datetime.now(datetime.timezone.utc)
+            # if tokens.expires_at is not None and tokens.expires_at <= now:
+            #     logger.debug(f"Token expired for {self.get_base_url(self.server_url)}")
+            #     return None
+            return tokens
+        except (FileNotFoundError, json.JSONDecodeError, ValidationError) as e:
+            logger.debug(
+                f"Could not load tokens for {self.get_base_url(self.server_url)}: {e}"
+            )
+            return None
+
+    async def set_tokens(self, tokens: OAuthToken) -> None:
+        """Save tokens to file storage."""
+        path = self._get_file_path("tokens")
+        path.write_text(tokens.model_dump_json(indent=2))
+        logger.debug(f"Saved tokens for {self.get_base_url(self.server_url)}")
+
+    async def get_client_info(self) -> OAuthClientInformationFull | None:
+        """Load client information from file storage."""
+        path = self._get_file_path("client_info")
+        try:
+            client_info = OAuthClientInformationFull.model_validate_json(
+                path.read_text()
+            )
+            # Check if we have corresponding valid tokens
+            # If no tokens exist, the OAuth flow was incomplete and we should
+            # force a fresh client registration
+            tokens = await self.get_tokens()
+            if tokens is None:
+                logger.debug(
+                    f"No tokens found for client info at {self.get_base_url(self.server_url)}. "
+                    "OAuth flow may have been incomplete. Clearing client info to force fresh registration."
+                )
+                # Clear the incomplete client info
+                client_info_path = self._get_file_path("client_info")
+                client_info_path.unlink(missing_ok=True)
+                return None
+
+            return client_info
+        except (FileNotFoundError, json.JSONDecodeError, ValidationError) as e:
+            logger.debug(
+                f"Could not load client info for {self.get_base_url(self.server_url)}: {e}"
+            )
+            return None
+
+    async def set_client_info(self, client_info: OAuthClientInformationFull) -> None:
+        """Save client information to file storage."""
+        path = self._get_file_path("client_info")
+        path.write_text(client_info.model_dump_json(indent=2))
+        logger.debug(f"Saved client info for {self.get_base_url(self.server_url)}")
+
+    def clear(self) -> None:
+        """Clear all cached data for this server."""
+        file_types: list[Literal["client_info", "tokens"]] = ["client_info", "tokens"]
+        for file_type in file_types:
+            path = self._get_file_path(file_type)
+            path.unlink(missing_ok=True)
+        logger.info(f"Cleared OAuth cache for {self.get_base_url(self.server_url)}")
+
+    @classmethod
+    def clear_all(cls, cache_dir: Path | None = None) -> None:
+        """Clear all cached data for all servers."""
+        cache_dir = cache_dir or default_cache_dir()
+        if not cache_dir.exists():
+            return
+
+        file_types: list[Literal["client_info", "tokens"]] = ["client_info", "tokens"]
+        for file_type in file_types:
+            for file in cache_dir.glob(f"*_{file_type}.json"):
+                file.unlink(missing_ok=True)
+        logger.info("Cleared all OAuth client cache data.")
+
+
+async def discover_oauth_metadata(
+    server_base_url: str, httpx_kwargs: dict[str, Any] | None = None
+) -> _MCPServerOAuthMetadata | 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 _MCPServerOAuthMetadata.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:
+    """
+    Check if the MCP endpoint requires authentication by making a test request.
+
+    Returns:
+        True if auth appears to be required, False otherwise
+    """
+    async with httpx.AsyncClient(**(httpx_kwargs or {})) as client:
+        try:
+            # Try a simple request to the endpoint
+            response = await client.get(mcp_url, timeout=5.0)
+
+            # If we get 401/403, auth is likely required
+            if response.status_code in (401, 403):
+                return True
+
+            # Check for WWW-Authenticate header
+            if "WWW-Authenticate" in response.headers:
+                return True
+
+            # If we get a successful response, auth may not be required
+            return False
+
+        except httpx.RequestError:
+            # If we can't connect, assume auth might be 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,
+) -> _MCPOAuthClientProvider:
+    """
+    Create an OAuthClientProvider for an MCP server.
+
+    This is intended to be provided to the `auth` parameter of an
+    httpx.AsyncClient (or appropriate FastMCP client/transport instance)
+
+    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
+
+    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:
+        """Open browser for authorization."""
+        logger.info(f"OAuth authorization URL: {authorization_url}")
+        webbrowser.open(authorization_url)
+
+    async def callback_handler() -> 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,
+            response_future=response_future,
+        )
+
+        # Run server until response is received with timeout logic
+        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}"
+            )
+
+            TIMEOUT = 300.0  # 5 minute timeout
+            try:
+                with anyio.fail_after(TIMEOUT):
+                    auth_code, state = await response_future
+                    return auth_code, state
+            except TimeoutError:
+                raise TimeoutError(f"OAuth callback timed out after {TIMEOUT} seconds")
+            finally:
+                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
+
+
+class BearerAuth(httpx.Auth):
+    def __init__(self, token: str):
+        self.token = token
+
+    def auth_flow(self, request):
+        request.headers["Authorization"] = f"Bearer {self.token}"
+        yield request

src/fastmcp/client/client.py

@@ -1,9 +1,11 @@
+import asyncio
 import datetime
 from contextlib import AsyncExitStack, asynccontextmanager
 from pathlib import Path
-from typing import Any, Generic, cast, overload
+from typing import Any, Generic, Literal, cast, overload
 
 import anyio
+import httpx
 import mcp.types
 from exceptiongroup import catch
 from mcp import ClientSession
@@ -43,6 +45,7 @@ from .transports import (
 
 __all__ = [
     "Client",
+    "SessionKwargs",
     "RootsHandler",
     "RootsList",
     "LogHandler",
@@ -142,11 +145,11 @@ class Client(Generic[ClientTransportT]):
         progress_handler: ProgressHandler | None = None,
         timeout: datetime.timedelta | float | int | None = None,
         init_timeout: datetime.timedelta | float | int | None = None,
+        auth: httpx.Auth | Literal["oauth"] | str | None = None,
     ):
         self.transport = cast(ClientTransportT, infer_transport(transport))
-        self._session: ClientSession | None = None
-        self._exit_stack: AsyncExitStack | None = None
-        self._nesting_counter: int = 0
+        if auth is not None:
+            self.transport._set_auth(auth)
         self._initialize_result: mcp.types.InitializeResult | None = None
 
         if log_handler is None:
@@ -187,6 +190,15 @@ class Client(Generic[ClientTransportT]):
                 sampling_handler
             )
 
+        # session context management
+        self._session: ClientSession | None = None
+        self._exit_stack: AsyncExitStack | None = None
+        self._nesting_counter: int = 0
+        self._context_lock = anyio.Lock()
+        self._session_task: asyncio.Task | None = None
+        self._ready_event = anyio.Event()
+        self._stop_event = anyio.Event()
+
     @property
     def session(self) -> ClientSession:
         """Get the current active session. Raises RuntimeError if not connected."""
@@ -237,39 +249,75 @@ class Client(Generic[ClientTransportT]):
                 except TimeoutError:
                     raise RuntimeError("Failed to initialize server session")
                 finally:
-                    self._exit_stack = None
                     self._session = None
                     self._initialize_result = None
 
     async def __aenter__(self):
-        if self._nesting_counter == 0:
-            # Create exit stack to manage both context managers
-            stack = AsyncExitStack()
-            await stack.__aenter__()
-
-            await stack.enter_async_context(self._context_manager())
-
-            self._exit_stack = stack
-
-        self._nesting_counter += 1
-
+        await self._connect()
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        self._nesting_counter -= 1
+        await self._disconnect()
+
+    async def _connect(self):
+        # ensure only one session is running at a time to avoid race conditions
+        async with self._context_lock:
+            need_to_start = self._session_task is None or self._session_task.done()
+            if need_to_start:
+                self._stop_event = anyio.Event()
+                self._ready_event = anyio.Event()
+                self._session_task = asyncio.create_task(self._session_runner())
+            await self._ready_event.wait()
+            self._nesting_counter += 1
+        return self
 
-        if self._nesting_counter == 0:
-            # Exit the stack which will handle cleaning up the session
-            if self._exit_stack is not None:
-                try:
-                    await self._exit_stack.__aexit__(exc_type, exc_val, exc_tb)
-                finally:
-                    self._exit_stack = None
+    async def _disconnect(self, force: bool = False):
+        # ensure only one session is running at a time to avoid race conditions
+        async with self._context_lock:
+            # if we are forcing a disconnect, reset the nesting counter
+            if force:
+                self._nesting_counter = 0
+
+            # otherwise decrement to check if we are done nesting
+            else:
+                self._nesting_counter = max(0, self._nesting_counter - 1)
+
+            # if we are still nested, return
+            if self._nesting_counter > 0:
+                return
+
+            # stop the active seesion
+            if self._session_task is None:
+                return
+            self._stop_event.set()
+            runner_task = self._session_task
+            self._session_task = None
+
+        # wait for the session to finish
+        if runner_task:
+            await runner_task
+
+        # Reset for future reconnects
+        self._stop_event = anyio.Event()
+        self._ready_event = anyio.Event()
+        self._session = None
+        self._initialize_result = None
+
+    async def _session_runner(self):
+        async with AsyncExitStack() as stack:
+            try:
+                await stack.enter_async_context(self._context_manager())
+                # Session/context is now ready
+                self._ready_event.set()
+                # Wait until disconnect/stop is requested
+                await self._stop_event.wait()
+            finally:
+                # On exit, ensure ready event is set (idempotent)
+                self._ready_event.set()
 
     async def close(self):
+        await self._disconnect(force=True)
         await self.transport.close()
-        self._session = None
-        self._initialize_result = None
 
     # --- MCP Client Methods ---
 

src/fastmcp/client/oauth_callback.py

@@ -0,0 +1,310 @@
+"""
+OAuth callback server for handling authorization code flows.
+
+This module provides a reusable callback server that can handle OAuth redirects
+and display styled responses to users.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+
+from starlette.applications import Starlette
+from starlette.requests import Request
+from starlette.responses import HTMLResponse
+from starlette.routing import Route
+from uvicorn import Config, Server
+
+from fastmcp.utilities.http import find_available_port
+from fastmcp.utilities.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def create_callback_html(
+    message: str,
+    is_success: bool = True,
+    title: str = "FastMCP OAuth",
+    server_url: str | None = None,
+) -> str:
+    """Create a styled HTML response for OAuth callbacks."""
+    status_emoji = "✅" if is_success else "❌"
+    status_color = "#10b981" if is_success else "#ef4444"  # emerald-500 / red-500
+
+    # Add server info for success cases
+    server_info = ""
+    if is_success and server_url:
+        server_info = f"""
+            <div class="server-info">
+                Connected to: <strong>{server_url}</strong>
+            </div>
+        """
+
+    return f"""
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>{title}</title>
+        <style>
+            body {{
+                font-family: 'SF Mono', 'Monaco', 'Consolas', 'Roboto Mono', monospace;
+                margin: 0;
+                padding: 0;
+                min-height: 100vh;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                background: linear-gradient(135deg, #0f0f23 0%, #1a1a2e 25%, #16213e 50%, #0f0f23 100%);
+                color: #e2e8f0;
+                overflow: hidden;
+            }}
+            
+            body::before {{
+                content: '';
+                position: fixed;
+                top: 0;
+                left: 0;
+                width: 100%;
+                height: 100%;
+                background: 
+                    radial-gradient(circle at 20% 80%, rgba(120, 119, 198, 0.1) 0%, transparent 50%),
+                    radial-gradient(circle at 80% 20%, rgba(16, 185, 129, 0.1) 0%, transparent 50%),
+                    radial-gradient(circle at 40% 40%, rgba(14, 165, 233, 0.1) 0%, transparent 50%);
+                pointer-events: none;
+                z-index: -1;
+            }}
+            
+            .container {{
+                background: rgba(30, 41, 59, 0.9);
+                backdrop-filter: blur(10px);
+                border: 1px solid rgba(71, 85, 105, 0.3);
+                padding: 3rem 2rem;
+                border-radius: 1rem;
+                box-shadow: 
+                    0 25px 50px -12px rgba(0, 0, 0, 0.7),
+                    0 0 0 1px rgba(255, 255, 255, 0.05),
+                    inset 0 1px 0 0 rgba(255, 255, 255, 0.1);
+                text-align: center;
+                max-width: 500px;
+                margin: 1rem;
+                position: relative;
+            }}
+            
+            .container::before {{
+                content: '';
+                position: absolute;
+                top: 0;
+                left: 0;
+                right: 0;
+                height: 1px;
+                background: linear-gradient(90deg, transparent, rgba(16, 185, 129, 0.5), transparent);
+            }}
+            
+            .status-icon {{
+                font-size: 4rem;
+                margin-bottom: 1rem;
+                display: block;
+                filter: drop-shadow(0 0 20px currentColor);
+            }}
+            
+            .message {{
+                font-size: 1.25rem;
+                line-height: 1.6;
+                color: {status_color};
+                margin-bottom: 1.5rem;
+                font-weight: 600;
+                text-shadow: 0 0 10px rgba({
+        "16, 185, 129" if is_success else "239, 68, 68"
+    }, 0.3);
+            }}
+            
+            .server-info {{
+                background: rgba(6, 182, 212, 0.1);
+                border: 1px solid rgba(6, 182, 212, 0.3);
+                border-radius: 0.75rem;
+                padding: 1rem;
+                margin: 1rem 0;
+                font-size: 0.9rem;
+                color: #67e8f9;
+                font-family: 'SF Mono', 'Monaco', 'Consolas', 'Roboto Mono', monospace;
+                text-shadow: 0 0 10px rgba(103, 232, 249, 0.3);
+            }}
+            
+            .server-info strong {{
+                color: #22d3ee;
+                font-weight: 700;
+            }}
+            
+            .subtitle {{
+                font-size: 1rem;
+                color: #94a3b8;
+                margin-top: 1rem;
+            }}
+            
+            .close-instruction {{
+                background: rgba(51, 65, 85, 0.8);
+                border: 1px solid rgba(71, 85, 105, 0.4);
+                border-radius: 0.75rem;
+                padding: 1rem;
+                margin-top: 1.5rem;
+                font-size: 0.9rem;
+                color: #cbd5e1;
+                font-family: 'SF Mono', 'Monaco', 'Consolas', 'Roboto Mono', monospace;
+            }}
+            
+            @keyframes glow {{
+                0%, 100% {{ opacity: 1; }}
+                50% {{ opacity: 0.7; }}
+            }}
+            
+            .status-icon {{
+                animation: glow 2s ease-in-out infinite;
+            }}
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <span class="status-icon">{status_emoji}</span>
+            <div class="message">{message}</div>
+            {server_info}
+            <div class="close-instruction">
+                You can safely close this tab now.
+            </div>
+        </div>
+    </body>
+    </html>
+    """
+
+
+@dataclass
+class CallbackResponse:
+    code: str | None = None
+    state: str | None = None
+    error: str | None = None
+    error_description: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, str]) -> CallbackResponse:
+        return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
+
+    def to_dict(self) -> dict[str, str]:
+        return {k: v for k, v in self.__dict__.items() if v is not None}
+
+
+def create_oauth_callback_server(
+    port: int,
+    callback_path: str = "/callback",
+    server_url: str | None = None,
+    response_future: asyncio.Future | None = None,
+) -> Server:
+    """
+    Create an OAuth callback server.
+
+    Args:
+        port: The port to run the server on
+        callback_path: The path to listen for OAuth redirects on
+        server_url: Optional server URL to display in success messages
+        response_future: Optional future to resolve when OAuth callback is received
+
+    Returns:
+        Configured uvicorn Server instance (not yet running)
+    """
+
+    async def callback_handler(request: Request):
+        """Handle OAuth callback requests with proper HTML responses."""
+        query_params = dict(request.query_params)
+        callback_response = CallbackResponse.from_dict(query_params)
+
+        if callback_response.error:
+            error_desc = callback_response.error_description or "Unknown error"
+
+            # Resolve future with exception if provided
+            if response_future and not response_future.done():
+                response_future.set_exception(
+                    RuntimeError(
+                        f"OAuth error: {callback_response.error} - {error_desc}"
+                    )
+                )
+
+            return HTMLResponse(
+                create_callback_html(
+                    f"FastMCP OAuth Error: {callback_response.error}<br>{error_desc}",
+                    is_success=False,
+                ),
+                status_code=400,
+            )
+
+        if not callback_response.code:
+            # Resolve future with exception if provided
+            if response_future and not response_future.done():
+                response_future.set_exception(
+                    RuntimeError("OAuth callback missing authorization code")
+                )
+
+            return HTMLResponse(
+                create_callback_html(
+                    "FastMCP OAuth Error: No authorization code received",
+                    is_success=False,
+                ),
+                status_code=400,
+            )
+
+        # Success case
+        if response_future and not response_future.done():
+            response_future.set_result(
+                (callback_response.code, callback_response.state)
+            )
+
+        return HTMLResponse(
+            create_callback_html("FastMCP OAuth login complete!", server_url=server_url)
+        )
+
+    app = Starlette(routes=[Route(callback_path, callback_handler)])
+
+    return Server(
+        Config(
+            app=app,
+            host="127.0.0.1",
+            port=port,
+            lifespan="off",
+            log_level="warning",
+        )
+    )
+
+
+if __name__ == "__main__":
+    """Run a test server when executed directly."""
+    import webbrowser
+
+    import uvicorn
+
+    port = find_available_port()
+    print("🎭 OAuth Callback Test Server")
+    print("📍 Test URLs:")
+    print(f"  Success: http://localhost:{port}/callback?code=test123&state=xyz")
+    print(
+        f"  Error:   http://localhost:{port}/callback?error=access_denied&error_description=User%20denied"
+    )
+    print(f"  Missing: http://localhost:{port}/callback")
+    print("🛑 Press Ctrl+C to stop")
+    print()
+
+    # Create test server without future (just for testing HTML responses)
+    server = create_oauth_callback_server(
+        port=port, server_url="https://fastmcp-test-server.example.com"
+    )
+
+    # Open browser to success example
+    webbrowser.open(f"http://localhost:{port}/callback?code=test123&state=xyz")
+
+    # Run with uvicorn directly
+    uvicorn.run(
+        server.config.app,
+        host="127.0.0.1",
+        port=port,
+        log_level="warning",
+        access_log=False,
+    )

src/fastmcp/client/transports.py

@@ -6,10 +6,20 @@ import os
 import shutil
 import sys
 import warnings
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Callable
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, TypedDict, TypeVar, cast, overload
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    TypedDict,
+    TypeVar,
+    cast,
+    overload,
+)
 
+import anyio
+import httpx
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.session import (
     ListRootsFnT,
@@ -26,7 +36,7 @@ from mcp.shared.memory import create_connected_server_and_client_session
 from pydantic import AnyUrl
 from typing_extensions import Unpack
 
-from fastmcp.server import FastMCP as FastMCPServer
+from fastmcp.client.auth import OAuth
 from fastmcp.server.dependencies import get_http_headers
 from fastmcp.server.server import FastMCP
 from fastmcp.utilities.logging import get_logger
@@ -40,6 +50,20 @@ logger = get_logger(__name__)
 # TypeVar for preserving specific ClientTransport subclass types
 ClientTransportT = TypeVar("ClientTransportT", bound="ClientTransport")
 
+__all__ = [
+    "ClientTransport",
+    "SSETransport",
+    "StreamableHttpTransport",
+    "StdioTransport",
+    "PythonStdioTransport",
+    "FastMCPStdioTransport",
+    "NodeStdioTransport",
+    "UvxStdioTransport",
+    "NpxStdioTransport",
+    "FastMCPTransport",
+    "infer_transport",
+]
+
 
 class SessionKwargs(TypedDict, total=False):
     """Keyword arguments for the MCP ClientSession constructor."""
@@ -92,6 +116,10 @@ class ClientTransport(abc.ABC):
         """Close the transport."""
         pass
 
+    def _set_auth(self, auth: httpx.Auth | Literal["oauth"] | str | None):
+        if auth is not None:
+            raise ValueError("This transport does not support auth")
+
 
 class WSTransport(ClientTransport):
     """Transport implementation that connects to an MCP server via WebSockets."""
@@ -131,7 +159,9 @@ class SSETransport(ClientTransport):
         self,
         url: str | AnyUrl,
         headers: dict[str, str] | None = None,
+        auth: httpx.Auth | Literal["oauth"] | str | None = None,
         sse_read_timeout: datetime.timedelta | float | int | None = None,
+        httpx_client_factory: Callable[[], httpx.AsyncClient] | None = None,
     ):
         if isinstance(url, AnyUrl):
             url = str(url)
@@ -139,11 +169,21 @@ class SSETransport(ClientTransport):
             raise ValueError("Invalid HTTP/S URL provided for SSE.")
         self.url = url
         self.headers = headers or {}
+        self._set_auth(auth)
+        self.httpx_client_factory = httpx_client_factory
 
         if isinstance(sse_read_timeout, int | float):
             sse_read_timeout = datetime.timedelta(seconds=sse_read_timeout)
         self.sse_read_timeout = sse_read_timeout
 
+    def _set_auth(self, auth: httpx.Auth | Literal["oauth"] | str | None):
+        if auth == "oauth":
+            auth = OAuth(self.url)
+        elif isinstance(auth, str):
+            self.headers["Authorization"] = auth
+            auth = None
+        self.auth = auth
+
     @contextlib.asynccontextmanager
     async def connect_session(
         self, **session_kwargs: Unpack[SessionKwargs]
@@ -165,7 +205,10 @@ class SSETransport(ClientTransport):
             )
             client_kwargs["timeout"] = read_timeout_seconds.total_seconds()
 
-        async with sse_client(self.url, **client_kwargs) as transport:
+        if self.httpx_client_factory is not None:
+            client_kwargs["httpx_client_factory"] = self.httpx_client_factory
+
+        async with sse_client(self.url, auth=self.auth, **client_kwargs) as transport:
             read_stream, write_stream = transport
             async with ClientSession(
                 read_stream, write_stream, **session_kwargs
@@ -183,7 +226,9 @@ class StreamableHttpTransport(ClientTransport):
         self,
         url: str | AnyUrl,
         headers: dict[str, str] | None = None,
+        auth: httpx.Auth | Literal["oauth"] | str | None = None,
         sse_read_timeout: datetime.timedelta | float | int | None = None,
+        httpx_client_factory: Callable[[], httpx.AsyncClient] | None = None,
     ):
         if isinstance(url, AnyUrl):
             url = str(url)
@@ -191,11 +236,21 @@ class StreamableHttpTransport(ClientTransport):
             raise ValueError("Invalid HTTP/S URL provided for Streamable HTTP.")
         self.url = url
         self.headers = headers or {}
+        self._set_auth(auth)
+        self.httpx_client_factory = httpx_client_factory
 
         if isinstance(sse_read_timeout, int | float):
             sse_read_timeout = datetime.timedelta(seconds=sse_read_timeout)
         self.sse_read_timeout = sse_read_timeout
 
+    def _set_auth(self, auth: httpx.Auth | Literal["oauth"] | str | None):
+        if auth == "oauth":
+            auth = OAuth(self.url)
+        elif isinstance(auth, str):
+            self.headers["Authorization"] = auth
+            auth = None
+        self.auth = auth
+
     @contextlib.asynccontextmanager
     async def connect_session(
         self, **session_kwargs: Unpack[SessionKwargs]
@@ -214,7 +269,14 @@ class StreamableHttpTransport(ClientTransport):
         if session_kwargs.get("read_timeout_seconds", None) is not None:
             client_kwargs["timeout"] = session_kwargs.get("read_timeout_seconds")
 
-        async with streamablehttp_client(self.url, **client_kwargs) as transport:
+        if self.httpx_client_factory is not None:
+            client_kwargs["httpx_client_factory"] = self.httpx_client_factory
+
+        async with streamablehttp_client(
+            self.url,
+            auth=self.auth,
+            **client_kwargs,
+        ) as transport:
             read_stream, write_stream, _ = transport
             async with ClientSession(
                 read_stream, write_stream, **session_kwargs
@@ -264,8 +326,8 @@ class StdioTransport(ClientTransport):
 
         self._session: ClientSession | None = None
         self._connect_task: asyncio.Task | None = None
-        self._ready_event = asyncio.Event()
-        self._stop_event = asyncio.Event()
+        self._ready_event = anyio.Event()
+        self._stop_event = anyio.Event()
 
     @contextlib.asynccontextmanager
     async def connect_session(
@@ -328,8 +390,8 @@ class StdioTransport(ClientTransport):
 
         # reset variables and events for potential future reconnects
         self._connect_task = None
-        self._stop_event = asyncio.Event()
-        self._ready_event = asyncio.Event()
+        self._stop_event = anyio.Event()
+        self._ready_event = anyio.Event()
 
     async def close(self):
         await self.disconnect()
@@ -592,7 +654,7 @@ class FastMCPTransport(ClientTransport):
     tests or scenarios where client and server run in the same runtime.
     """
 
-    def __init__(self, mcp: FastMCPServer | FastMCP1Server):
+    def __init__(self, mcp: FastMCP | FastMCP1Server):
         """Initialize a FastMCPTransport from a FastMCP server instance."""
 
         # Accept both FastMCP 2.x and FastMCP 1.0 servers. Both expose a
@@ -706,7 +768,7 @@ def infer_transport(transport: ClientTransportT) -> ClientTransportT: ...
 
 
 @overload
-def infer_transport(transport: FastMCPServer) -> FastMCPTransport: ...
+def infer_transport(transport: FastMCP) -> FastMCPTransport: ...
 
 
 @overload
@@ -741,7 +803,7 @@ def infer_transport(transport: Path) -> PythonStdioTransport | NodeStdioTranspor
 
 def infer_transport(
     transport: ClientTransport
-    | FastMCPServer
+    | FastMCP
     | FastMCP1Server
     | AnyUrl
     | Path
@@ -758,7 +820,7 @@ def infer_transport(
 
     The function supports these input types:
     - ClientTransport: Used directly without modification
-    - FastMCPServer or FastMCP1Server: Creates an in-memory FastMCPTransport
+    - FastMCP or FastMCP1Server: Creates an in-memory FastMCPTransport
     - Path or str (file path): Creates PythonStdioTransport (.py) or NodeStdioTransport (.js)
     - AnyUrl or str (URL): Creates StreamableHttpTransport (default) or SSETransport (for /sse endpoints)
     - MCPConfig or dict: Creates MCPConfigTransport, potentially connecting to multiple servers
@@ -796,7 +858,7 @@ def infer_transport(
         return transport
 
     # the transport is a FastMCP server (2.x or 1.0)
-    elif isinstance(transport, FastMCPServer | FastMCP1Server):
+    elif isinstance(transport, FastMCP | FastMCP1Server):
         inferred_transport = FastMCPTransport(mcp=transport)
 
     # the transport is a path to a script

src/fastmcp/low_level/README.md

@@ -1 +0,0 @@
-Patched low-level objects. When possible, we prefer the official SDK, but we patch bugs here if necessary.

src/fastmcp/server/auth/auth.py

@@ -0,0 +1,45 @@
+from mcp.server.auth.provider import (
+    AccessToken,
+    AuthorizationCode,
+    OAuthAuthorizationServerProvider,
+    RefreshToken,
+)
+from mcp.server.auth.settings import (
+    ClientRegistrationOptions,
+    RevocationOptions,
+)
+from pydantic import AnyHttpUrl
+
+
+class OAuthProvider(
+    OAuthAuthorizationServerProvider[AuthorizationCode, RefreshToken, AccessToken]
+):
+    def __init__(
+        self,
+        issuer_url: AnyHttpUrl | str,
+        service_documentation_url: AnyHttpUrl | str | None = None,
+        client_registration_options: ClientRegistrationOptions | None = None,
+        revocation_options: RevocationOptions | None = None,
+        required_scopes: list[str] | None = None,
+    ):
+        """
+        Initialize the OAuth provider.
+
+        Args:
+            issuer_url: The URL of the OAuth issuer.
+            service_documentation_url: The URL of the service documentation.
+            client_registration_options: The client registration options.
+            revocation_options: The revocation options.
+            required_scopes: Scopes that are required for all requests.
+        """
+        super().__init__()
+        if isinstance(issuer_url, str):
+            issuer_url = AnyHttpUrl(issuer_url)
+        if isinstance(service_documentation_url, str):
+            service_documentation_url = AnyHttpUrl(service_documentation_url)
+
+        self.issuer_url = issuer_url
+        self.service_documentation_url = service_documentation_url
+        self.client_registration_options = client_registration_options
+        self.revocation_options = revocation_options
+        self.required_scopes = required_scopes

src/fastmcp/server/auth/providers/bearer.py

@@ -0,0 +1,377 @@
+import time
+from dataclasses import dataclass
+from typing import Any, TypedDict
+
+import httpx
+from authlib.jose import JsonWebKey, JsonWebToken
+from authlib.jose.errors import JoseError
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+from mcp.server.auth.provider import (
+    AccessToken,
+    AuthorizationCode,
+    AuthorizationParams,
+    RefreshToken,
+)
+from mcp.shared.auth import (
+    OAuthClientInformationFull,
+    OAuthToken,
+)
+from pydantic import SecretStr
+
+from fastmcp.server.auth.auth import (
+    ClientRegistrationOptions,
+    OAuthProvider,
+    RevocationOptions,
+)
+
+
+class JWKData(TypedDict, total=False):
+    """JSON Web Key data structure."""
+
+    kty: str  # Key type (e.g., "RSA") - required
+    kid: str  # Key ID (optional but recommended)
+    use: str  # Usage (e.g., "sig")
+    alg: str  # Algorithm (e.g., "RS256")
+    n: str  # Modulus (for RSA keys)
+    e: str  # Exponent (for RSA keys)
+    x5c: list[str]  # X.509 certificate chain (for JWKs)
+    x5t: str  # X.509 certificate thumbprint (for JWKs)
+
+
+class JWKSData(TypedDict):
+    """JSON Web Key Set data structure."""
+
+    keys: list[JWKData]
+
+
+@dataclass(frozen=True, kw_only=True, repr=False)
+class RSAKeyPair:
+    private_key: SecretStr
+    public_key: str
+
+    @classmethod
+    def generate(cls) -> "RSAKeyPair":
+        """
+        Generate an RSA key pair for testing.
+
+        Returns:
+            tuple: (private_key_pem, public_key_pem)
+        """
+        # Generate private key
+        private_key = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=2048,
+        )
+
+        # Get public key
+        public_key = private_key.public_key()
+
+        # Serialize private key to PEM format
+        private_pem = private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        ).decode("utf-8")
+
+        # Serialize public key to PEM format
+        public_pem = public_key.public_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo,
+        ).decode("utf-8")
+
+        return cls(
+            private_key=SecretStr(private_pem),
+            public_key=public_pem,
+        )
+
+    def create_token(
+        self,
+        subject: str = "fastmcp-user",
+        issuer: str = "https://fastmcp.example.com",
+        audience: str | None = None,
+        scopes: list[str] | None = None,
+        expires_in_seconds: int = 3600,
+        additional_claims: dict[str, Any] | None = None,
+        kid: str | None = None,
+    ) -> str:
+        """
+        Generate a test JWT token for testing purposes.
+
+        Args:
+            private_key_pem: RSA private key in PEM format
+            subject: Subject claim (usually user ID)
+            issuer: Issuer claim
+            audience: Audience claim (optional)
+            scopes: List of scopes to include
+            expires_in_seconds: Token expiration time in seconds
+            additional_claims: Any additional claims to include
+            kid: Key ID for JWKS lookup (optional)
+
+        Returns:
+            Signed JWT token string
+        """
+        jwt = JsonWebToken(["RS256"])
+
+        now = int(time.time())
+
+        # Build payload
+        payload = {
+            "iss": issuer,
+            "sub": subject,
+            "iat": now,
+            "exp": now + expires_in_seconds,
+        }
+
+        if audience:
+            payload["aud"] = audience
+
+        if scopes:
+            payload["scope"] = " ".join(scopes)
+
+        if additional_claims:
+            payload.update(additional_claims)
+
+        # Create header
+        header = {"alg": "RS256"}
+        if kid:
+            header["kid"] = kid
+
+        # Sign and return token
+        token_bytes = jwt.encode(
+            header,
+            payload,
+            key=self.private_key.get_secret_value(),
+        )
+        return token_bytes.decode("utf-8")
+
+
+class BearerAuthProvider(OAuthProvider):
+    """
+    Simple JWT Bearer Token validator for hosted MCP servers.
+    Uses RS256 asymmetric encryption. Supports either static public key
+    or JWKS URI for key rotation.
+
+    Note that this provider DOES NOT permit client registration or revocation, or any OAuth flows.
+    It is intended to be used with a control plane that manages clients and tokens.
+    """
+
+    def __init__(
+        self,
+        public_key: str | None = None,
+        jwks_uri: str | None = None,
+        issuer: str | None = None,
+        audience: str | None = None,
+        required_scopes: list[str] | None = None,
+    ):
+        """
+        Initialize the provider. Either public_key or jwks_uri must be provided.
+
+        Args:
+            public_key: RSA public key in PEM format (for static key)
+            jwks_uri: URI to fetch keys from (for key rotation)
+            issuer: Expected issuer claim (optional)
+            audience: Expected audience claim (optional)
+            required_scopes: List of required scopes for access (optional)
+        """
+        if not (public_key or jwks_uri):
+            raise ValueError("Either public_key or jwks_uri must be provided")
+        if public_key and jwks_uri:
+            raise ValueError("Provide either public_key or jwks_uri, not both")
+
+        super().__init__(
+            issuer_url=issuer or "https://fastmcp.example.com",
+            client_registration_options=ClientRegistrationOptions(enabled=False),
+            revocation_options=RevocationOptions(enabled=False),
+            required_scopes=required_scopes,
+        )
+
+        self.issuer = issuer
+        self.audience = audience
+        self.public_key = public_key
+        self.jwks_uri = jwks_uri
+        self.jwt = JsonWebToken(["RS256"])
+
+        # Simple JWKS cache
+        self._jwks_cache: dict[str, str] = {}
+        self._jwks_cache_time: float = 0
+        self._cache_ttl = 3600  # 1 hour
+
+    async def _get_verification_key(self, token: str) -> str:
+        """Get the verification key for the token."""
+        if self.public_key:
+            return self.public_key
+
+        # Extract kid from token header for JWKS lookup
+        try:
+            import base64
+            import json
+
+            header_b64 = token.split(".")[0]
+            header_b64 += "=" * (4 - len(header_b64) % 4)  # Add padding
+            header = json.loads(base64.urlsafe_b64decode(header_b64))
+            kid = header.get("kid")
+
+            return await self._get_jwks_key(kid)
+
+        except Exception as e:
+            raise ValueError(f"Failed to extract key ID from token: {e}")
+
+    async def _get_jwks_key(self, kid: str | None) -> str:
+        """Fetch key from JWKS with simple caching."""
+        if not self.jwks_uri:
+            raise ValueError("JWKS URI not configured")
+
+        current_time = time.time()
+
+        # Check cache first
+        if current_time - self._jwks_cache_time < self._cache_ttl:
+            if kid and kid in self._jwks_cache:
+                return self._jwks_cache[kid]
+            elif not kid and len(self._jwks_cache) == 1:
+                # If no kid but only one key cached, use it
+                return next(iter(self._jwks_cache.values()))
+
+        # Fetch JWKS
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(self.jwks_uri)
+                response.raise_for_status()
+                jwks_data = response.json()
+
+            # Cache all keys
+            self._jwks_cache = {}
+            for key_data in jwks_data.get("keys", []):
+                key_kid = key_data.get("kid")
+                jwk = JsonWebKey.import_key(key_data)
+                public_key = jwk.get_public_key()  # type: ignore
+
+                if key_kid:
+                    self._jwks_cache[key_kid] = public_key
+                else:
+                    # Key without kid - use a default identifier
+                    self._jwks_cache["_default"] = public_key
+
+            self._jwks_cache_time = current_time
+
+            # Select the appropriate key
+            if kid:
+                if kid not in self._jwks_cache:
+                    raise ValueError(f"Key ID '{kid}' not found in JWKS")
+                return self._jwks_cache[kid]
+            else:
+                # No kid in token - only allow if there's exactly one key
+                if len(self._jwks_cache) == 1:
+                    return next(iter(self._jwks_cache.values()))
+                elif len(self._jwks_cache) > 1:
+                    raise ValueError(
+                        "Multiple keys in JWKS but no key ID (kid) in token"
+                    )
+                else:
+                    raise ValueError("No keys found in JWKS")
+
+        except Exception as e:
+            raise ValueError(f"Failed to fetch JWKS: {e}")
+
+    async def load_access_token(self, token: str) -> AccessToken | None:
+        """
+        Validates the provided JWT bearer token.
+
+        Args:
+            token: The JWT token string to validate
+
+        Returns:
+            AccessToken object if valid, None if invalid or expired
+        """
+        try:
+            # Get verification key (static or from JWKS)
+            verification_key = await self._get_verification_key(token)
+
+            # Decode and verify the JWT token
+            claims = self.jwt.decode(token, verification_key)
+
+            # Validate expiration
+            exp = claims.get("exp")
+            if exp and exp < time.time():
+                return None
+
+            # Validate issuer - note we use issuer instead of issuer_url here because
+            # issuer is optional, allowing users to make this check optional
+            if self.issuer:
+                if claims.get("iss") != self.issuer:
+                    return None
+
+            # Validate audience if configured
+            if self.audience:
+                aud = claims.get("aud")
+                if isinstance(aud, list):
+                    if self.audience not in aud:
+                        return None
+                elif aud != self.audience:
+                    return None
+
+            # Extract claims - prefer client_id over sub for OAuth application identification
+            client_id = claims.get("client_id") or claims.get("sub") or "unknown"
+            scopes = self._extract_scopes(claims)
+
+            return AccessToken(
+                token=token,
+                client_id=str(client_id),
+                scopes=scopes,
+                expires_at=int(exp) if exp else None,
+            )
+
+        except JoseError:
+            return None
+        except Exception:
+            return None
+
+    def _extract_scopes(self, claims: dict[str, Any]) -> list[str]:
+        """Extract scopes from JWT claims."""
+        scope_claim = claims.get("scope", "")
+        if isinstance(scope_claim, str):
+            return scope_claim.split()
+        elif isinstance(scope_claim, list):
+            return scope_claim
+        return []
+
+    # --- Unused OAuth server methods ---
+    async def get_client(self, client_id: str) -> OAuthClientInformationFull | None:
+        raise NotImplementedError("Client management not supported")
+
+    async def register_client(self, client_info: OAuthClientInformationFull) -> None:
+        raise NotImplementedError("Client registration not supported")
+
+    async def authorize(
+        self, client: OAuthClientInformationFull, params: AuthorizationParams
+    ) -> str:
+        raise NotImplementedError("Authorization flow not supported")
+
+    async def load_authorization_code(
+        self, client: OAuthClientInformationFull, authorization_code: str
+    ) -> AuthorizationCode | None:
+        raise NotImplementedError("Authorization code flow not supported")
+
+    async def exchange_authorization_code(
+        self, client: OAuthClientInformationFull, authorization_code: AuthorizationCode
+    ) -> OAuthToken:
+        raise NotImplementedError("Authorization code exchange not supported")
+
+    async def load_refresh_token(
+        self, client: OAuthClientInformationFull, refresh_token: str
+    ) -> RefreshToken | None:
+        raise NotImplementedError("Refresh token flow not supported")
+
+    async def exchange_refresh_token(
+        self,
+        client: OAuthClientInformationFull,
+        refresh_token: RefreshToken,
+        scopes: list[str],
+    ) -> OAuthToken:
+        raise NotImplementedError("Refresh token exchange not supported")
+
+    async def revoke_token(
+        self,
+        token: AccessToken | RefreshToken,
+    ) -> None:
+        raise NotImplementedError("Token revocation not supported")

src/fastmcp/server/auth/providers/bearer_env.py

@@ -0,0 +1,62 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from fastmcp.server.auth.providers.bearer import BearerAuthProvider
+
+
+# Sentinel object to indicate that a setting is not set
+class _NotSet:
+    pass
+
+
+class EnvBearerAuthProviderSettings(BaseSettings):
+    """Settings for the BearerAuthProvider."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="FASTMCP_AUTH_BEARER_",
+        env_file=".env",
+        extra="ignore",
+    )
+
+    public_key: str | None = None
+    jwks_uri: str | None = None
+    issuer: str | None = None
+    audience: str | None = None
+    required_scopes: list[str] | None = None
+
+
+class EnvBearerAuthProvider(BearerAuthProvider):
+    """
+    A BearerAuthProvider that loads settings from environment variables. Any
+    providing setting will always take precedence over the environment
+    variables.
+    """
+
+    def __init__(
+        self,
+        public_key: str | None | type[_NotSet] = _NotSet,
+        jwks_uri: str | None | type[_NotSet] = _NotSet,
+        issuer: str | None | type[_NotSet] = _NotSet,
+        audience: str | None | type[_NotSet] = _NotSet,
+        required_scopes: list[str] | None | type[_NotSet] = _NotSet,
+    ):
+        """
+        Initialize the provider.
+
+        Args:
+            public_key: RSA public key in PEM format (for static key)
+            jwks_uri: URI to fetch keys from (for key rotation)
+            issuer: Expected issuer claim (optional)
+            audience: Expected audience claim (optional)
+            required_scopes: List of required scopes for access (optional)
+        """
+        kwargs = {
+            "public_key": public_key,
+            "jwks_uri": jwks_uri,
+            "issuer": issuer,
+            "audience": audience,
+            "required_scopes": required_scopes,
+        }
+        settings = EnvBearerAuthProviderSettings(
+            **{k: v for k, v in kwargs.items() if v is not _NotSet}
+        )
+        super().__init__(**settings.model_dump())

src/fastmcp/server/auth/providers/in_memory.py

@@ -0,0 +1,330 @@
+"""
+This is a simple in-memory OAuth provider for testing purposes.
+It simulates the OAuth 2.0 flow locally without external calls.
+"""
+
+import secrets
+import time
+
+from mcp.server.auth.provider import (
+    AccessToken,
+    AuthorizationCode,
+    AuthorizationParams,
+    AuthorizeError,
+    RefreshToken,
+    TokenError,
+    construct_redirect_uri,
+)
+from mcp.shared.auth import (
+    OAuthClientInformationFull,
+    OAuthToken,
+)
+from pydantic import AnyHttpUrl
+
+from fastmcp.server.auth.auth import (
+    ClientRegistrationOptions,
+    OAuthProvider,
+    RevocationOptions,
+)
+
+# Default expiration times (in seconds)
+DEFAULT_AUTH_CODE_EXPIRY_SECONDS = 5 * 60  # 5 minutes
+DEFAULT_ACCESS_TOKEN_EXPIRY_SECONDS = 60 * 60  # 1 hour
+DEFAULT_REFRESH_TOKEN_EXPIRY_SECONDS = None  # No expiry
+
+
+class InMemoryOAuthProvider(OAuthProvider):
+    """
+    An in-memory OAuth provider for testing purposes.
+    It simulates the OAuth 2.0 flow locally without external calls.
+    """
+
+    def __init__(
+        self,
+        issuer_url: AnyHttpUrl | str | None = None,
+        service_documentation_url: AnyHttpUrl | str | None = None,
+        client_registration_options: ClientRegistrationOptions | None = None,
+        revocation_options: RevocationOptions | None = None,
+        required_scopes: list[str] | None = None,
+    ):
+        super().__init__(
+            issuer_url=issuer_url or "http://fastmcp.example.com",
+            service_documentation_url=service_documentation_url,
+            client_registration_options=client_registration_options,
+            revocation_options=revocation_options,
+            required_scopes=required_scopes,
+        )
+        self.clients: dict[str, OAuthClientInformationFull] = {}
+        self.auth_codes: dict[str, AuthorizationCode] = {}
+        self.access_tokens: dict[str, AccessToken] = {}
+        self.refresh_tokens: dict[str, RefreshToken] = {}
+
+        # For revoking associated tokens
+        self._access_to_refresh_map: dict[
+            str, str
+        ] = {}  # access_token_str -> refresh_token_str
+        self._refresh_to_access_map: dict[
+            str, str
+        ] = {}  # refresh_token_str -> access_token_str
+
+    async def get_client(self, client_id: str) -> OAuthClientInformationFull | None:
+        return self.clients.get(client_id)
+
+    async def register_client(self, client_info: OAuthClientInformationFull) -> None:
+        if client_info.client_id in self.clients:
+            # As per RFC 7591, if client_id is already known, it's an update.
+            # For this simple provider, we'll treat it as re-registration.
+            # A real provider might handle updates or raise errors for conflicts.
+            pass
+        self.clients[client_info.client_id] = client_info
+
+    async def authorize(
+        self, client: OAuthClientInformationFull, params: AuthorizationParams
+    ) -> str:
+        """
+        Simulates user authorization and generates an authorization code.
+        Returns a redirect URI with the code and state.
+        """
+        if client.client_id not in self.clients:
+            raise AuthorizeError(
+                error="unauthorized_client",
+                error_description=f"Client '{client.client_id}' not registered.",
+            )
+
+        # Validate redirect_uri (already validated by AuthorizationHandler, but good practice)
+        try:
+            # OAuthClientInformationFull should have a method like validate_redirect_uri
+            # For this test provider, we assume it's valid if it matches one in client_info
+            # The AuthorizationHandler already does robust validation using client.validate_redirect_uri
+            if params.redirect_uri not in client.redirect_uris:
+                # This check might be too simplistic if redirect_uris can be patterns
+                # or if params.redirect_uri is None and client has a default.
+                # However, the AuthorizationHandler handles the primary validation.
+                pass  # Let's assume AuthorizationHandler did its job.
+        except Exception:  # Replace with specific validation error if client.validate_redirect_uri existed
+            raise AuthorizeError(
+                error="invalid_request", error_description="Invalid redirect_uri."
+            )
+
+        auth_code_value = f"test_auth_code_{secrets.token_hex(16)}"
+        expires_at = time.time() + DEFAULT_AUTH_CODE_EXPIRY_SECONDS
+
+        # Ensure scopes are a list
+        scopes_list = params.scopes if params.scopes is not None else []
+        if client.scope:  # Filter params.scopes against client's registered scopes
+            client_allowed_scopes = set(client.scope.split())
+            scopes_list = [s for s in scopes_list if s in client_allowed_scopes]
+
+        auth_code = AuthorizationCode(
+            code=auth_code_value,
+            client_id=client.client_id,
+            redirect_uri=params.redirect_uri,
+            redirect_uri_provided_explicitly=params.redirect_uri_provided_explicitly,
+            scopes=scopes_list,
+            expires_at=expires_at,
+            code_challenge=params.code_challenge,
+            # code_challenge_method is assumed S256 by the framework
+        )
+        self.auth_codes[auth_code_value] = auth_code
+
+        return construct_redirect_uri(
+            str(params.redirect_uri), code=auth_code_value, state=params.state
+        )
+
+    async def load_authorization_code(
+        self, client: OAuthClientInformationFull, authorization_code: str
+    ) -> AuthorizationCode | None:
+        auth_code_obj = self.auth_codes.get(authorization_code)
+        if auth_code_obj:
+            if auth_code_obj.client_id != client.client_id:
+                return None  # Belongs to a different client
+            if auth_code_obj.expires_at < time.time():
+                del self.auth_codes[authorization_code]  # Expired
+                return None
+            return auth_code_obj
+        return None
+
+    async def exchange_authorization_code(
+        self, client: OAuthClientInformationFull, authorization_code: AuthorizationCode
+    ) -> OAuthToken:
+        # Authorization code should have been validated (existence, expiry, client_id match)
+        # by the TokenHandler calling load_authorization_code before this.
+        # We might want to re-verify or simply trust it's valid.
+
+        if authorization_code.code not in self.auth_codes:
+            raise TokenError(
+                "invalid_grant", "Authorization code not found or already used."
+            )
+
+        # Consume the auth code
+        del self.auth_codes[authorization_code.code]
+
+        access_token_value = f"test_access_token_{secrets.token_hex(32)}"
+        refresh_token_value = f"test_refresh_token_{secrets.token_hex(32)}"
+
+        access_token_expires_at = int(time.time() + DEFAULT_ACCESS_TOKEN_EXPIRY_SECONDS)
+
+        # Refresh token expiry
+        refresh_token_expires_at = None
+        if DEFAULT_REFRESH_TOKEN_EXPIRY_SECONDS is not None:
+            refresh_token_expires_at = int(
+                time.time() + DEFAULT_REFRESH_TOKEN_EXPIRY_SECONDS
+            )
+
+        self.access_tokens[access_token_value] = AccessToken(
+            token=access_token_value,
+            client_id=client.client_id,
+            scopes=authorization_code.scopes,
+            expires_at=access_token_expires_at,
+        )
+        self.refresh_tokens[refresh_token_value] = RefreshToken(
+            token=refresh_token_value,
+            client_id=client.client_id,
+            scopes=authorization_code.scopes,  # Refresh token inherits scopes
+            expires_at=refresh_token_expires_at,
+        )
+
+        self._access_to_refresh_map[access_token_value] = refresh_token_value
+        self._refresh_to_access_map[refresh_token_value] = access_token_value
+
+        return OAuthToken(
+            access_token=access_token_value,
+            token_type="bearer",
+            expires_in=DEFAULT_ACCESS_TOKEN_EXPIRY_SECONDS,
+            refresh_token=refresh_token_value,
+            scope=" ".join(authorization_code.scopes),
+        )
+
+    async def load_refresh_token(
+        self, client: OAuthClientInformationFull, refresh_token: str
+    ) -> RefreshToken | None:
+        token_obj = self.refresh_tokens.get(refresh_token)
+        if token_obj:
+            if token_obj.client_id != client.client_id:
+                return None  # Belongs to different client
+            if token_obj.expires_at is not None and token_obj.expires_at < time.time():
+                self._revoke_internal(
+                    refresh_token_str=token_obj.token
+                )  # Clean up expired
+                return None
+            return token_obj
+        return None
+
+    async def exchange_refresh_token(
+        self,
+        client: OAuthClientInformationFull,
+        refresh_token: RefreshToken,  # This is the RefreshToken object, already loaded
+        scopes: list[str],  # Requested scopes for the new access token
+    ) -> OAuthToken:
+        # Validate scopes: requested scopes must be a subset of original scopes
+        original_scopes = set(refresh_token.scopes)
+        requested_scopes = set(scopes)
+        if not requested_scopes.issubset(original_scopes):
+            raise TokenError(
+                "invalid_scope",
+                "Requested scopes exceed those authorized by the refresh token.",
+            )
+
+        # Invalidate old refresh token and its associated access token (rotation)
+        self._revoke_internal(refresh_token_str=refresh_token.token)
+
+        # Issue new tokens
+        new_access_token_value = f"test_access_token_{secrets.token_hex(32)}"
+        new_refresh_token_value = f"test_refresh_token_{secrets.token_hex(32)}"
+
+        access_token_expires_at = int(time.time() + DEFAULT_ACCESS_TOKEN_EXPIRY_SECONDS)
+
+        # Refresh token expiry
+        refresh_token_expires_at = None
+        if DEFAULT_REFRESH_TOKEN_EXPIRY_SECONDS is not None:
+            refresh_token_expires_at = int(
+                time.time() + DEFAULT_REFRESH_TOKEN_EXPIRY_SECONDS
+            )
+
+        self.access_tokens[new_access_token_value] = AccessToken(
+            token=new_access_token_value,
+            client_id=client.client_id,
+            scopes=scopes,  # Use newly requested (and validated) scopes
+            expires_at=access_token_expires_at,
+        )
+        self.refresh_tokens[new_refresh_token_value] = RefreshToken(
+            token=new_refresh_token_value,
+            client_id=client.client_id,
+            scopes=scopes,  # New refresh token also gets these scopes
+            expires_at=refresh_token_expires_at,
+        )
+
+        self._access_to_refresh_map[new_access_token_value] = new_refresh_token_value
+        self._refresh_to_access_map[new_refresh_token_value] = new_access_token_value
+
+        return OAuthToken(
+            access_token=new_access_token_value,
+            token_type="bearer",
+            expires_in=DEFAULT_ACCESS_TOKEN_EXPIRY_SECONDS,
+            refresh_token=new_refresh_token_value,
+            scope=" ".join(scopes),
+        )
+
+    async def load_access_token(self, token: str) -> AccessToken | None:
+        token_obj = self.access_tokens.get(token)
+        if token_obj:
+            if token_obj.expires_at is not None and token_obj.expires_at < time.time():
+                self._revoke_internal(
+                    access_token_str=token_obj.token
+                )  # Clean up expired
+                return None
+            return token_obj
+        return None
+
+    def _revoke_internal(
+        self, access_token_str: str | None = None, refresh_token_str: str | None = None
+    ):
+        """Internal helper to remove tokens and their associations."""
+        removed_access_token = None
+        removed_refresh_token = None
+
+        if access_token_str:
+            if access_token_str in self.access_tokens:
+                del self.access_tokens[access_token_str]
+                removed_access_token = access_token_str
+
+            # Get associated refresh token
+            associated_refresh = self._access_to_refresh_map.pop(access_token_str, None)
+            if associated_refresh:
+                if associated_refresh in self.refresh_tokens:
+                    del self.refresh_tokens[associated_refresh]
+                    removed_refresh_token = associated_refresh
+                self._refresh_to_access_map.pop(associated_refresh, None)
+
+        if refresh_token_str:
+            if refresh_token_str in self.refresh_tokens:
+                del self.refresh_tokens[refresh_token_str]
+                removed_refresh_token = refresh_token_str
+
+            # Get associated access token
+            associated_access = self._refresh_to_access_map.pop(refresh_token_str, None)
+            if associated_access:
+                if associated_access in self.access_tokens:
+                    del self.access_tokens[associated_access]
+                    removed_access_token = associated_access
+                self._access_to_refresh_map.pop(associated_access, None)
+
+        # Clean up any dangling references if one part of the pair was already gone
+        if removed_access_token and removed_access_token in self._access_to_refresh_map:
+            del self._access_to_refresh_map[removed_access_token]
+        if (
+            removed_refresh_token
+            and removed_refresh_token in self._refresh_to_access_map
+        ):
+            del self._refresh_to_access_map[removed_refresh_token]
+
+    async def revoke_token(
+        self,
+        token: AccessToken | RefreshToken,
+    ) -> None:
+        """Revokes an access or refresh token and its counterpart."""
+        if isinstance(token, AccessToken):
+            self._revoke_internal(access_token_str=token.token)
+        elif isinstance(token, RefreshToken):
+            self._revoke_internal(refresh_token_str=token.token)
+        # If token is not found or already revoked, _revoke_internal does nothing, which is correct.

src/fastmcp/server/dependencies.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, ParamSpec, TypeVar
 
+from mcp.server.auth.middleware.auth_context import get_access_token
+from mcp.server.auth.provider import AccessToken
 from starlette.requests import Request
 
 if TYPE_CHECKING:
@@ -10,6 +12,14 @@ if TYPE_CHECKING:
 P = ParamSpec("P")
 R = TypeVar("R")
 
+__all__ = [
+    "get_context",
+    "get_http_request",
+    "get_http_headers",
+    "get_access_token",
+    "AccessToken",
+]
+
 
 # --- Context ---
 

src/fastmcp/server/http.py

@@ -10,14 +10,7 @@ from mcp.server.auth.middleware.bearer_auth import (
     BearerAuthBackend,
     RequireAuthMiddleware,
 )
-from mcp.server.auth.provider import (
-    AccessTokenT,
-    AuthorizationCodeT,
-    OAuthAuthorizationServerProvider,
-    RefreshTokenT,
-)
 from mcp.server.auth.routes import create_auth_routes
-from mcp.server.auth.settings import AuthSettings
 from mcp.server.lowlevel.server import LifespanResultT
 from mcp.server.sse import SseServerTransport
 from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
@@ -29,6 +22,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 OAuthProvider
 from fastmcp.utilities.logging import get_logger
 
 if TYPE_CHECKING:
@@ -75,17 +69,12 @@ class RequestContextMiddleware:
 
 
 def setup_auth_middleware_and_routes(
-    auth_server_provider: OAuthAuthorizationServerProvider[
-        AuthorizationCodeT, RefreshTokenT, AccessTokenT
-    ]
-    | None,
-    auth_settings: AuthSettings | None,
+    auth: OAuthProvider,
 ) -> tuple[list[Middleware], list[BaseRoute], list[str]]:
     """Set up authentication middleware and routes if auth is enabled.
 
     Args:
-        auth_server_provider: The OAuth authorization server provider
-        auth_settings: The auth settings
+        auth: The OAuthProvider authorization server provider
 
     Returns:
         Tuple of (middleware, auth_routes, required_scopes)
@@ -94,31 +83,25 @@ def setup_auth_middleware_and_routes(
     auth_routes: list[BaseRoute] = []
     required_scopes: list[str] = []
 
-    if auth_server_provider:
-        if not auth_settings:
-            raise ValueError(
-                "auth_settings must be provided when auth_server_provider is specified"
-            )
+    middleware = [
+        Middleware(
+            AuthenticationMiddleware,
+            backend=BearerAuthBackend(provider=auth),
+        ),
+        Middleware(AuthContextMiddleware),
+    ]
 
-        middleware = [
-            Middleware(
-                AuthenticationMiddleware,
-                backend=BearerAuthBackend(provider=auth_server_provider),
-            ),
-            Middleware(AuthContextMiddleware),
-        ]
-
-        required_scopes = auth_settings.required_scopes or []
-
-        auth_routes.extend(
-            create_auth_routes(
-                provider=auth_server_provider,
-                issuer_url=auth_settings.issuer_url,
-                service_documentation_url=auth_settings.service_documentation_url,
-                client_registration_options=auth_settings.client_registration_options,
-                revocation_options=auth_settings.revocation_options,
-            )
+    required_scopes = auth.required_scopes or []
+
+    auth_routes.extend(
+        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,
         )
+    )
 
     return middleware, auth_routes, required_scopes
 
@@ -155,11 +138,7 @@ def create_sse_app(
     server: FastMCP[LifespanResultT],
     message_path: str,
     sse_path: str,
-    auth_server_provider: OAuthAuthorizationServerProvider[
-        AuthorizationCodeT, RefreshTokenT, AccessTokenT
-    ]
-    | None = None,
-    auth_settings: AuthSettings | None = None,
+    auth: OAuthProvider | None = None,
     debug: bool = False,
     routes: list[BaseRoute] | None = None,
     middleware: list[Middleware] | None = None,
@@ -170,8 +149,7 @@ def create_sse_app(
         server: The FastMCP server instance
         message_path: Path for SSE messages
         sse_path: Path for SSE connections
-        auth_server_provider: Optional auth provider
-        auth_settings: Optional auth settings
+        auth: Optional auth provider
         debug: Whether to enable debug mode
         routes: Optional list of custom routes
         middleware: Optional list of middleware
@@ -196,15 +174,15 @@ def create_sse_app(
         return Response()
 
     # Get auth middleware and routes
-    auth_middleware, auth_routes, required_scopes = setup_auth_middleware_and_routes(
-        auth_server_provider, auth_settings
-    )
-
-    server_routes.extend(auth_routes)
-    server_middleware.extend(auth_middleware)
 
     # Add SSE routes with or without auth
-    if auth_server_provider:
+    if auth:
+        auth_middleware, auth_routes, required_scopes = (
+            setup_auth_middleware_and_routes(auth)
+        )
+
+        server_routes.extend(auth_routes)
+        server_middleware.extend(auth_middleware)
         # Auth is enabled, wrap endpoints with RequireAuthMiddleware
         server_routes.append(
             Route(
@@ -264,11 +242,7 @@ def create_streamable_http_app(
     server: FastMCP[LifespanResultT],
     streamable_http_path: str,
     event_store: None = None,
-    auth_server_provider: OAuthAuthorizationServerProvider[
-        AuthorizationCodeT, RefreshTokenT, AccessTokenT
-    ]
-    | None = None,
-    auth_settings: AuthSettings | None = None,
+    auth: OAuthProvider | None = None,
     json_response: bool = False,
     stateless_http: bool = False,
     debug: bool = False,
@@ -281,8 +255,7 @@ def create_streamable_http_app(
         server: The FastMCP server instance
         streamable_http_path: Path for StreamableHTTP connections
         event_store: Optional event store for session management
-        auth_server_provider: Optional auth provider
-        auth_settings: Optional auth settings
+        auth: Optional auth provider
         json_response: Whether to use JSON response format
         stateless_http: Whether to use stateless mode (new transport per request)
         debug: Whether to enable debug mode
@@ -331,16 +304,15 @@ def create_streamable_http_app(
                 # Re-raise other RuntimeErrors if they don't match the specific message
                 raise
 
-    # Get auth middleware and routes
-    auth_middleware, auth_routes, required_scopes = setup_auth_middleware_and_routes(
-        auth_server_provider, auth_settings
-    )
+    # Add StreamableHTTP routes with or without auth
+    if auth:
+        auth_middleware, auth_routes, required_scopes = (
+            setup_auth_middleware_and_routes(auth)
+        )
 
-    server_routes.extend(auth_routes)
-    server_middleware.extend(auth_middleware)
+        server_routes.extend(auth_routes)
+        server_middleware.extend(auth_middleware)
 
-    # Add StreamableHTTP routes with or without auth
-    if auth_server_provider:
         # Auth is enabled, wrap endpoint with RequireAuthMiddleware
         server_routes.append(
             Mount(

src/fastmcp/server/server.py

@@ -18,7 +18,6 @@ from typing import TYPE_CHECKING, Any, Generic, Literal
 import anyio
 import httpx
 import uvicorn
-from mcp.server.auth.provider import OAuthAuthorizationServerProvider
 from mcp.server.lowlevel.helper_types import ReadResourceContents
 from mcp.server.lowlevel.server import LifespanResultT, NotificationOptions
 from mcp.server.lowlevel.server import Server as MCPServer
@@ -48,6 +47,8 @@ from fastmcp.prompts import Prompt, PromptManager
 from fastmcp.prompts.prompt import PromptResult
 from fastmcp.resources import Resource, ResourceManager
 from fastmcp.resources.template import ResourceTemplate
+from fastmcp.server.auth.auth import OAuthProvider
+from fastmcp.server.auth.providers.bearer_env import EnvBearerAuthProvider
 from fastmcp.server.http import (
     StarletteWithLifespan,
     create_sse_app,
@@ -110,8 +111,7 @@ class FastMCP(Generic[LifespanResultT]):
         self,
         name: str | None = None,
         instructions: str | None = None,
-        auth_server_provider: OAuthAuthorizationServerProvider[Any, Any, Any]
-        | None = None,
+        auth: OAuthProvider | None = None,
         lifespan: (
             Callable[
                 [FastMCP[LifespanResultT]],
@@ -128,6 +128,7 @@ class FastMCP(Generic[LifespanResultT]):
         on_duplicate_prompts: DuplicateBehavior | None = None,
         resource_prefix_format: Literal["protocol", "path"] | None = None,
         mask_error_details: bool | None = None,
+        tools: list[Tool | Callable[..., Any]] | None = None,
         **settings: Any,
     ):
         if settings:
@@ -186,13 +187,16 @@ class FastMCP(Generic[LifespanResultT]):
             lifespan=_lifespan_wrapper(self, lifespan),
         )
 
-        if (self.settings.auth is not None) != (auth_server_provider is not None):
-            # TODO: after we support separate authorization servers (see
-            raise ValueError(
-                "settings.auth must be specified if and only if auth_server_provider "
-                "is specified"
-            )
-        self._auth_server_provider = auth_server_provider
+        if auth is None and self.settings.default_auth_provider == "bearer_env":
+            auth = EnvBearerAuthProvider()
+        self.auth = auth
+
+        if tools:
+            for tool in tools:
+                if isinstance(tool, Tool):
+                    self._tool_manager.add_tool(tool)
+                else:
+                    self.add_tool(tool)
 
         # Set up MCP protocol handlers
         self._setup_handlers()
@@ -907,8 +911,7 @@ class FastMCP(Generic[LifespanResultT]):
             server=self,
             message_path=message_path or self.settings.message_path,
             sse_path=path or self.settings.sse_path,
-            auth_server_provider=self._auth_server_provider,
-            auth_settings=self.settings.auth,
+            auth=self.auth,
             debug=self.settings.debug,
             middleware=middleware,
         )
@@ -955,8 +958,7 @@ class FastMCP(Generic[LifespanResultT]):
                 server=self,
                 streamable_http_path=path or self.settings.streamable_http_path,
                 event_store=None,
-                auth_server_provider=self._auth_server_provider,
-                auth_settings=self.settings.auth,
+                auth=self.auth,
                 json_response=self.settings.json_response,
                 stateless_http=self.settings.stateless_http,
                 debug=self.settings.debug,
@@ -967,8 +969,7 @@ class FastMCP(Generic[LifespanResultT]):
                 server=self,
                 message_path=self.settings.message_path,
                 sse_path=path or self.settings.sse_path,
-                auth_server_provider=self._auth_server_provider,
-                auth_settings=self.settings.auth,
+                auth=self.auth,
                 debug=self.settings.debug,
                 middleware=middleware,
             )

src/fastmcp/settings.py

@@ -1,16 +1,16 @@
 from __future__ import annotations as _annotations
 
 import inspect
-from typing import TYPE_CHECKING, Annotated, Literal
+from pathlib import Path
+from typing import Annotated, Literal
 
-from mcp.server.auth.settings import AuthSettings
 from pydantic import Field, model_validator
-from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic_settings import (
+    BaseSettings,
+    SettingsConfigDict,
+)
 from typing_extensions import Self
 
-if TYPE_CHECKING:
-    pass
-
 LOG_LEVEL = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
 
 DuplicateBehavior = Literal["warn", "error", "replace", "ignore"]
@@ -27,6 +27,8 @@ class Settings(BaseSettings):
         nested_model_default_partial_update=True,
     )
 
+    home: Path = Path.home() / ".fastmcp"
+
     test_mode: bool = False
     log_level: LOG_LEVEL = "INFO"
     enable_rich_tracebacks: Annotated[
@@ -171,13 +173,30 @@ class ServerSettings(BaseSettings):
     # cache settings (for checking mounted servers)
     cache_expiration_seconds: float = 0
 
-    auth: AuthSettings | None = None
-
     # StreamableHTTP settings
     json_response: bool = False
     stateless_http: bool = (
         False  # If True, uses true stateless mode (new transport per request)
     )
 
+    # Auth settings
+    default_auth_provider: Annotated[
+        Literal["bearer_env"] | None,
+        Field(
+            description=inspect.cleandoc(
+                """
+                Configure the authentication provider. This setting is intended only to
+                be used for remote confirugation of providers that fully support
+                environment variable configuration.
+
+                If None, no automatic configuration will take place.
+
+                This setting is *always* overriden by any auth provider passed to the
+                FastMCP constructor.
+                """
+            ),
+        ),
+    ] = None
+
 
 settings = Settings()

src/fastmcp/utilities/http.py

@@ -0,0 +1,8 @@
+import socket
+
+
+def find_available_port() -> int:
+    """Find an available port by letting the OS assign one."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]

src/fastmcp/utilities/tests.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING, Any, Literal
 import uvicorn
 
 from fastmcp.settings import settings
+from fastmcp.utilities.http import find_available_port
 
 if TYPE_CHECKING:
     from fastmcp.server.server import FastMCP
@@ -71,30 +72,38 @@ def _run_server(mcp_server: FastMCP, transport: Literal["sse"], port: int) -> No
 
 @contextmanager
 def run_server_in_process(
-    server_fn: Callable[..., None], *args
+    server_fn: Callable[..., None],
+    *args,
+    provide_host_and_port: bool = True,
+    **kwargs,
 ) -> Generator[str, None, None]:
     """
-    Context manager that runs a Starlette app in a separate process and returns the
-    server URL. When the context manager is exited, the server process is killed.
+    Context manager that runs a FastMCP server in a separate process and
+    returns the server URL. When the context manager is exited, the server process is killed.
 
     Args:
-        app: The Starlette app to run.
+        server_fn: The function that runs a FastMCP server. FastMCP servers are
+            not pickleable, so we need a function that creates and runs one.
+        *args: Arguments to pass to the server function.
+        provide_host_and_port: Whether to provide the host and port to the server function as kwargs.
+        **kwargs: Keyword arguments to pass to the server function.
 
     Returns:
         The server URL.
     """
     host = "127.0.0.1"
-    with socket.socket() as s:
-        s.bind((host, 0))
-        port = s.getsockname()[1]
+    port = find_available_port()
+
+    if provide_host_and_port:
+        kwargs |= {"host": host, "port": port}
 
     proc = multiprocessing.Process(
-        target=server_fn, args=(host, port, *args), daemon=True
+        target=server_fn, args=args, kwargs=kwargs, daemon=True
     )
     proc.start()
 
     # Wait for server to be running
-    max_attempts = 100
+    max_attempts = 10
     attempt = 0
     while attempt < max_attempts and proc.is_alive():
         try:
@@ -102,7 +111,10 @@ def run_server_in_process(
                 s.connect((host, port))
                 break
         except ConnectionRefusedError:
-            time.sleep(0.01)
+            if attempt < 3:
+                time.sleep(0.01)
+            else:
+                time.sleep(0.1)
             attempt += 1
     else:
         raise RuntimeError(f"Server failed to start after {max_attempts} attempts")

tests/auth/providers/test_bearer.py

@@ -0,0 +1,635 @@
+from collections.abc import Generator
+from typing import Any
+
+import httpx
+import pytest
+from pytest_httpx import HTTPXMock
+
+from fastmcp import Client, FastMCP
+from fastmcp.client.auth import BearerAuth
+from fastmcp.server.auth.providers.bearer import (
+    BearerAuthProvider,
+    JWKData,
+    JWKSData,
+    RSAKeyPair,
+)
+from fastmcp.utilities.tests import run_server_in_process
+
+
+@pytest.fixture(scope="module")
+def rsa_key_pair() -> RSAKeyPair:
+    return RSAKeyPair.generate()
+
+
+@pytest.fixture(scope="module")
+def bearer_token(rsa_key_pair: RSAKeyPair) -> str:
+    return rsa_key_pair.create_token(
+        subject="test-user",
+        issuer="https://test.example.com",
+        audience="https://api.example.com",
+    )
+
+
+@pytest.fixture
+def bearer_provider(rsa_key_pair: RSAKeyPair) -> BearerAuthProvider:
+    return BearerAuthProvider(
+        public_key=rsa_key_pair.public_key,
+        issuer="https://test.example.com",
+        audience="https://api.example.com",
+    )
+
+
+def run_mcp_server(
+    public_key: str,
+    host: str,
+    port: int,
+    auth_kwargs: dict[str, Any] | None = None,
+    run_kwargs: dict[str, Any] | None = None,
+) -> None:
+    mcp = FastMCP(
+        auth=BearerAuthProvider(
+            public_key=public_key,
+            **auth_kwargs or {},
+        )
+    )
+
+    @mcp.tool()
+    def add(a: int, b: int) -> int:
+        return a + b
+
+    mcp.run(host=host, port=port, **run_kwargs or {})
+
+
+@pytest.fixture(scope="module")
+def mcp_server_url(rsa_key_pair: RSAKeyPair) -> Generator[str]:
+    with run_server_in_process(
+        run_mcp_server,
+        public_key=rsa_key_pair.public_key,
+        run_kwargs=dict(transport="streamable-http"),
+    ) as url:
+        yield f"{url}/mcp"
+
+
+class TestRSAKeyPair:
+    def test_generate_key_pair(self):
+        """Test RSA key pair generation."""
+        key_pair = RSAKeyPair.generate()
+
+        assert key_pair.private_key is not None
+        assert key_pair.public_key is not None
+
+        # Check that keys are in PEM format
+        private_pem = key_pair.private_key.get_secret_value()
+        public_pem = key_pair.public_key
+
+        assert "-----BEGIN PRIVATE KEY-----" in private_pem
+        assert "-----END PRIVATE KEY-----" in private_pem
+        assert "-----BEGIN PUBLIC KEY-----" in public_pem
+        assert "-----END PUBLIC KEY-----" in public_pem
+
+    def test_create_basic_token(self, rsa_key_pair: RSAKeyPair):
+        """Test basic token creation."""
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+        )
+
+        assert isinstance(token, str)
+        assert len(token.split(".")) == 3  # JWT has 3 parts
+
+    def test_create_token_with_scopes(self, rsa_key_pair: RSAKeyPair):
+        """Test token creation with scopes."""
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            scopes=["read", "write"],
+        )
+
+        assert isinstance(token, str)
+        # We'll validate the scopes in the BearerToken tests
+
+
+class TestBearerTokenJWKS:
+    """Tests for JWKS URI functionality."""
+
+    @pytest.fixture
+    def jwks_provider(self, rsa_key_pair: RSAKeyPair) -> BearerAuthProvider:
+        """Provider configured with JWKS URI."""
+        return BearerAuthProvider(
+            jwks_uri="https://test.example.com/.well-known/jwks.json",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+        )
+
+    @pytest.fixture
+    def mock_jwks_data(self, rsa_key_pair: RSAKeyPair) -> JWKSData:
+        """Create mock JWKS data from RSA key pair."""
+        from authlib.jose import JsonWebKey
+
+        # Create JWK from the RSA public key
+        jwk = JsonWebKey.import_key(rsa_key_pair.public_key)  # type: ignore
+        jwk_data: JWKData = jwk.as_dict()  # type: ignore
+        jwk_data["kid"] = "test-key-1"
+        jwk_data["alg"] = "RS256"
+
+        return {"keys": [jwk_data]}
+
+    async def test_jwks_token_validation(
+        self,
+        rsa_key_pair: RSAKeyPair,
+        jwks_provider: BearerAuthProvider,
+        mock_jwks_data: JWKSData,
+        httpx_mock: HTTPXMock,
+    ):
+        """Test token validation using JWKS URI."""
+        httpx_mock.add_response(
+            url="https://test.example.com/.well-known/jwks.json",
+            json=mock_jwks_data,
+        )
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+        )
+
+        access_token = await jwks_provider.load_access_token(token)
+        assert access_token is not None
+        assert access_token.client_id == "test-user"
+
+    async def test_jwks_token_validation_with_invalid_key(
+        self,
+        rsa_key_pair: RSAKeyPair,
+        jwks_provider: BearerAuthProvider,
+        mock_jwks_data: JWKSData,
+        httpx_mock: HTTPXMock,
+    ):
+        httpx_mock.add_response(
+            url="https://test.example.com/.well-known/jwks.json",
+            json=mock_jwks_data,
+        )
+        token = RSAKeyPair.generate().create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+        )
+
+        access_token = await jwks_provider.load_access_token(token)
+        assert access_token is None
+
+    async def test_jwks_token_validation_with_kid(
+        self,
+        rsa_key_pair: RSAKeyPair,
+        jwks_provider: BearerAuthProvider,
+        mock_jwks_data: JWKSData,
+        httpx_mock: HTTPXMock,
+    ):
+        mock_jwks_data["keys"][0]["kid"] = "test-key-1"
+        httpx_mock.add_response(
+            url="https://test.example.com/.well-known/jwks.json",
+            json=mock_jwks_data,
+        )
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+            kid="test-key-1",
+        )
+
+        access_token = await jwks_provider.load_access_token(token)
+        assert access_token is not None
+        assert access_token.client_id == "test-user"
+
+    async def test_jwks_token_validation_with_kid_and_no_kid_in_token(
+        self,
+        rsa_key_pair: RSAKeyPair,
+        jwks_provider: BearerAuthProvider,
+        mock_jwks_data: JWKSData,
+        httpx_mock: HTTPXMock,
+    ):
+        mock_jwks_data["keys"][0]["kid"] = "test-key-1"
+        httpx_mock.add_response(
+            url="https://test.example.com/.well-known/jwks.json",
+            json=mock_jwks_data,
+        )
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+        )
+
+        access_token = await jwks_provider.load_access_token(token)
+        assert access_token is not None
+        assert access_token.client_id == "test-user"
+
+    async def test_jwks_token_validation_with_no_kid_and_kid_in_jwks(
+        self,
+        rsa_key_pair: RSAKeyPair,
+        jwks_provider: BearerAuthProvider,
+        mock_jwks_data: JWKSData,
+        httpx_mock: HTTPXMock,
+    ):
+        mock_jwks_data["keys"][0]["kid"] = "test-key-1"
+        httpx_mock.add_response(
+            url="https://test.example.com/.well-known/jwks.json",
+            json=mock_jwks_data,
+        )
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+        )
+
+        access_token = await jwks_provider.load_access_token(token)
+        assert access_token is not None
+        assert access_token.client_id == "test-user"
+
+    async def test_jwks_token_validation_with_kid_mismatch(
+        self,
+        rsa_key_pair: RSAKeyPair,
+        jwks_provider: BearerAuthProvider,
+        mock_jwks_data: JWKSData,
+        httpx_mock: HTTPXMock,
+    ):
+        mock_jwks_data["keys"][0]["kid"] = "test-key-1"
+        httpx_mock.add_response(
+            url="https://test.example.com/.well-known/jwks.json",
+            json=mock_jwks_data,
+        )
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+            kid="test-key-2",
+        )
+
+        access_token = await jwks_provider.load_access_token(token)
+        assert access_token is None
+
+    async def test_jwks_token_validation_with_multiple_keys_and_no_kid_in_token(
+        self,
+        rsa_key_pair: RSAKeyPair,
+        jwks_provider: BearerAuthProvider,
+        mock_jwks_data: JWKSData,
+        httpx_mock: HTTPXMock,
+    ):
+        mock_jwks_data["keys"] = [
+            {
+                "kid": "test-key-1",
+                "alg": "RS256",
+            },
+            {
+                "kid": "test-key-2",
+                "alg": "RS256",
+            },
+        ]
+
+        httpx_mock.add_response(
+            url="https://test.example.com/.well-known/jwks.json",
+            json=mock_jwks_data,
+        )
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+        )
+
+        access_token = await jwks_provider.load_access_token(token)
+        assert access_token is None
+
+
+class TestBearerToken:
+    def test_initialization_with_public_key(self, rsa_key_pair: RSAKeyPair):
+        """Test provider initialization with public key."""
+        provider = BearerAuthProvider(
+            public_key=rsa_key_pair.public_key, issuer="https://test.example.com"
+        )
+
+        assert provider.issuer == "https://test.example.com"
+        assert provider.public_key is not None
+        assert provider.jwks_uri is None
+
+    def test_initialization_with_jwks_uri(self):
+        """Test provider initialization with JWKS URI."""
+        provider = BearerAuthProvider(
+            jwks_uri="https://test.example.com/.well-known/jwks.json",
+            issuer="https://test.example.com",
+        )
+
+        assert provider.issuer == "https://test.example.com"
+        assert provider.jwks_uri == "https://test.example.com/.well-known/jwks.json"
+        assert provider.public_key is None
+
+    def test_initialization_requires_key_or_uri(self):
+        """Test that either public_key or jwks_uri is required."""
+        with pytest.raises(
+            ValueError, match="Either public_key or jwks_uri must be provided"
+        ):
+            BearerAuthProvider(issuer="https://test.example.com")
+
+    def test_initialization_rejects_both_key_and_uri(self, rsa_key_pair: RSAKeyPair):
+        """Test that both public_key and jwks_uri cannot be provided."""
+        with pytest.raises(
+            ValueError, match="Provide either public_key or jwks_uri, not both"
+        ):
+            BearerAuthProvider(
+                public_key=rsa_key_pair.public_key,
+                jwks_uri="https://test.example.com/.well-known/jwks.json",
+                issuer="https://test.example.com",
+            )
+
+    async def test_valid_token_validation(
+        self, rsa_key_pair: RSAKeyPair, bearer_provider: BearerAuthProvider
+    ):
+        """Test validation of a valid token."""
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+            scopes=["read", "write"],
+        )
+
+        access_token = await bearer_provider.load_access_token(token)
+
+        assert access_token is not None
+        assert access_token.client_id == "test-user"
+        assert "read" in access_token.scopes
+        assert "write" in access_token.scopes
+        assert access_token.expires_at is not None
+
+    async def test_expired_token_rejection(
+        self, rsa_key_pair: RSAKeyPair, bearer_provider: BearerAuthProvider
+    ):
+        """Test rejection of expired tokens."""
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+            expires_in_seconds=-3600,  # Expired 1 hour ago
+        )
+
+        access_token = await bearer_provider.load_access_token(token)
+        assert access_token is None
+
+    async def test_invalid_issuer_rejection(
+        self, rsa_key_pair: RSAKeyPair, bearer_provider: BearerAuthProvider
+    ):
+        """Test rejection of tokens with invalid issuer."""
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://evil.example.com",  # Wrong issuer
+            audience="https://api.example.com",
+        )
+
+        access_token = await bearer_provider.load_access_token(token)
+        assert access_token is None
+
+    async def test_invalid_audience_rejection(
+        self, rsa_key_pair: RSAKeyPair, bearer_provider: BearerAuthProvider
+    ):
+        """Test rejection of tokens with invalid audience."""
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://wrong-api.example.com",  # Wrong audience
+        )
+
+        access_token = await bearer_provider.load_access_token(token)
+        assert access_token is None
+
+    async def test_no_issuer_validation_when_none(self, rsa_key_pair: RSAKeyPair):
+        """Test that issuer validation is skipped when provider has no issuer configured."""
+        provider = BearerAuthProvider(
+            public_key=rsa_key_pair.public_key,
+            issuer=None,  # No issuer validation
+        )
+
+        token = rsa_key_pair.create_token(
+            subject="test-user", issuer="https://any.example.com"
+        )
+
+        access_token = await provider.load_access_token(token)
+        assert access_token is not None
+
+    async def test_no_audience_validation_when_none(self, rsa_key_pair: RSAKeyPair):
+        """Test that audience validation is skipped when provider has no audience configured."""
+        provider = BearerAuthProvider(
+            public_key=rsa_key_pair.public_key,
+            issuer="https://test.example.com",
+            audience=None,  # No audience validation
+        )
+
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://any-api.example.com",
+        )
+
+        access_token = await provider.load_access_token(token)
+        assert access_token is not None
+
+    async def test_multiple_audiences_validation(self, rsa_key_pair: RSAKeyPair):
+        """Test validation with multiple audiences in token."""
+        provider = BearerAuthProvider(
+            public_key=rsa_key_pair.public_key,
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+        )
+
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            additional_claims={
+                "aud": ["https://api.example.com", "https://other-api.example.com"]
+            },
+        )
+
+        access_token = await provider.load_access_token(token)
+        assert access_token is not None
+
+    async def test_scope_extraction_string(
+        self, rsa_key_pair: RSAKeyPair, bearer_provider: BearerAuthProvider
+    ):
+        """Test scope extraction from space-separated string."""
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+            scopes=["read", "write", "admin"],
+        )
+
+        access_token = await bearer_provider.load_access_token(token)
+
+        assert access_token is not None
+        assert set(access_token.scopes) == {"read", "write", "admin"}
+
+    async def test_scope_extraction_list(
+        self, rsa_key_pair: RSAKeyPair, bearer_provider: BearerAuthProvider
+    ):
+        """Test scope extraction from list format."""
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+            additional_claims={"scope": ["read", "write"]},  # List format
+        )
+
+        access_token = await bearer_provider.load_access_token(token)
+
+        assert access_token is not None
+        assert set(access_token.scopes) == {"read", "write"}
+
+    async def test_no_scopes(
+        self, rsa_key_pair: RSAKeyPair, bearer_provider: BearerAuthProvider
+    ):
+        """Test token with no scopes."""
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+            # No scopes
+        )
+
+        access_token = await bearer_provider.load_access_token(token)
+
+        assert access_token is not None
+        assert access_token.scopes == []
+
+    async def test_malformed_token_rejection(self, bearer_provider: BearerAuthProvider):
+        """Test rejection of malformed tokens."""
+        malformed_tokens = [
+            "not.a.jwt",
+            "too.many.parts.here.invalid",
+            "invalid-token",
+            "",
+            "header.body",  # Missing signature
+        ]
+
+        for token in malformed_tokens:
+            access_token = await bearer_provider.load_access_token(token)
+            assert access_token is None
+
+    async def test_invalid_signature_rejection(
+        self, rsa_key_pair: RSAKeyPair, bearer_provider: BearerAuthProvider
+    ):
+        """Test rejection of tokens with invalid signatures."""
+        # Create a token with a different key pair
+        other_key_pair = RSAKeyPair.generate()
+        token = other_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+        )
+
+        access_token = await bearer_provider.load_access_token(token)
+        assert access_token is None
+
+    async def test_client_id_fallback(
+        self, rsa_key_pair: RSAKeyPair, bearer_provider: BearerAuthProvider
+    ):
+        """Test client_id extraction with fallback logic."""
+        # Test with explicit client_id claim
+        token = rsa_key_pair.create_token(
+            subject="user123",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+            additional_claims={"client_id": "app456"},
+        )
+
+        access_token = await bearer_provider.load_access_token(token)
+        assert access_token is not None
+        assert access_token.client_id == "app456"  # Should prefer client_id over sub
+
+
+class TestFastMCPBearerAuth:
+    def test_bearer_auth(self):
+        mcp = FastMCP(
+            auth=BearerAuthProvider(issuer="https://test.example.com", public_key="abc")
+        )
+        assert isinstance(mcp.auth, BearerAuthProvider)
+
+    async def test_unauthorized_access(self, mcp_server_url: str):
+        with pytest.raises(httpx.HTTPStatusError) as exc_info:
+            async with Client(mcp_server_url) as client:
+                tools = await client.list_tools()  # noqa: F841
+        assert exc_info.value.response.status_code == 401
+        assert "tools" not in locals()
+
+    async def test_authorized_access(self, mcp_server_url: str, bearer_token):
+        async with Client(mcp_server_url, auth=BearerAuth(bearer_token)) as client:
+            tools = await client.list_tools()  # noqa: F841
+        assert tools
+
+    async def test_invalid_token_raises_401(self, mcp_server_url: str):
+        with pytest.raises(httpx.HTTPStatusError) as exc_info:
+            async with Client(mcp_server_url, auth=BearerAuth("invalid")) as client:
+                tools = await client.list_tools()  # noqa: F841
+        assert exc_info.value.response.status_code == 401
+        assert "tools" not in locals()
+
+    async def test_expired_token(self, mcp_server_url: str, rsa_key_pair: RSAKeyPair):
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+            expires_in_seconds=-3600,
+        )
+
+        with pytest.raises(httpx.HTTPStatusError) as exc_info:
+            async with Client(mcp_server_url, auth=BearerAuth(token)) as client:
+                tools = await client.list_tools()  # noqa: F841
+        assert exc_info.value.response.status_code == 401
+        assert "tools" not in locals()
+
+    async def test_token_with_bad_signature(self, mcp_server_url: str):
+        rsa_key_pair = RSAKeyPair.generate()
+        token = rsa_key_pair.create_token()
+
+        with pytest.raises(httpx.HTTPStatusError) as exc_info:
+            async with Client(mcp_server_url, auth=BearerAuth(token)) as client:
+                tools = await client.list_tools()  # noqa: F841
+        assert exc_info.value.response.status_code == 401
+        assert "tools" not in locals()
+
+    async def test_token_with_insufficient_scopes(
+        self, mcp_server_url: str, rsa_key_pair: RSAKeyPair
+    ):
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+            scopes=["read"],
+        )
+
+        with run_server_in_process(
+            run_mcp_server,
+            public_key=rsa_key_pair.public_key,
+            auth_kwargs=dict(required_scopes=["read", "write"]),
+            run_kwargs=dict(transport="streamable-http"),
+        ) as url:
+            mcp_server_url = f"{url}/mcp"
+            with pytest.raises(httpx.HTTPStatusError) as exc_info:
+                async with Client(mcp_server_url, auth=BearerAuth(token)) as client:
+                    tools = await client.list_tools()  # noqa: F841
+            assert exc_info.value.response.status_code == 403
+            assert "tools" not in locals()
+
+    async def test_token_with_sufficient_scopes(
+        self, mcp_server_url: str, rsa_key_pair: RSAKeyPair
+    ):
+        token = rsa_key_pair.create_token(
+            subject="test-user",
+            issuer="https://test.example.com",
+            audience="https://api.example.com",
+            scopes=["read", "write"],
+        )
+
+        with run_server_in_process(
+            run_mcp_server,
+            public_key=rsa_key_pair.public_key,
+            auth_kwargs=dict(required_scopes=["read", "write"]),
+            run_kwargs=dict(transport="streamable-http"),
+        ) as url:
+            mcp_server_url = f"{url}/mcp"
+            async with Client(mcp_server_url, auth=BearerAuth(token)) as client:
+                tools = await client.list_tools()
+        assert tools

tests/auth/providers/test_bearer_env.py

@@ -0,0 +1,82 @@
+import pytest
+from pydantic import AnyHttpUrl, ValidationError
+
+from fastmcp import FastMCP
+from fastmcp.server.auth.providers.bearer import BearerAuthProvider
+from fastmcp.server.auth.providers.bearer_env import EnvBearerAuthProvider
+
+
+def test_load_bearer_env_from_env_var(monkeypatch):
+    mcp = FastMCP()
+    assert mcp.auth is None
+
+    monkeypatch.setenv("FASTMCP_SERVER_DEFAULT_AUTH_PROVIDER", "bearer_env")
+    monkeypatch.setenv("FASTMCP_AUTH_BEARER_PUBLIC_KEY", "test-public-key")
+
+    mcp_with_auth = FastMCP()
+    assert isinstance(mcp_with_auth.auth, EnvBearerAuthProvider)
+
+
+def test_load_bearer_env_from_env_var_requires_public_key_or_jwks_uri(monkeypatch):
+    mcp = FastMCP()
+    assert mcp.auth is None
+
+    monkeypatch.setenv("FASTMCP_SERVER_DEFAULT_AUTH_PROVIDER", "bearer_env")
+
+    with pytest.raises(
+        ValueError, match="Either public_key or jwks_uri must be provided"
+    ):
+        FastMCP()
+
+
+def test_configure_bearer_env_from_env_var(monkeypatch):
+    monkeypatch.setenv("FASTMCP_SERVER_DEFAULT_AUTH_PROVIDER", "bearer_env")
+    monkeypatch.setenv("FASTMCP_AUTH_BEARER_PUBLIC_KEY", "test-public-key")
+    monkeypatch.setenv("FASTMCP_AUTH_BEARER_ISSUER", "http://test-issuer")
+    monkeypatch.setenv("FASTMCP_AUTH_BEARER_AUDIENCE", "test-audience")
+    monkeypatch.setenv(
+        "FASTMCP_AUTH_BEARER_REQUIRED_SCOPES", '["test-scope1", "test-scope2"]'
+    )
+
+    mcp = FastMCP()
+    assert isinstance(mcp.auth, EnvBearerAuthProvider)
+    assert mcp.auth.public_key == "test-public-key"
+    assert mcp.auth.issuer_url == AnyHttpUrl("http://test-issuer")
+    assert mcp.auth.audience == "test-audience"
+    assert mcp.auth.required_scopes == ["test-scope1", "test-scope2"]
+
+
+def test_list_of_scopes_must_be_a_list(monkeypatch):
+    monkeypatch.setenv("FASTMCP_SERVER_DEFAULT_AUTH_PROVIDER", "bearer_env")
+    monkeypatch.setenv("FASTMCP_AUTH_BEARER_REQUIRED_SCOPES", "test-scope1")
+
+    with pytest.raises(ValidationError, match="Input should be a valid list"):
+        FastMCP()
+
+
+def test_configure_bearer_env_jwks_uri_from_env_var(monkeypatch):
+    monkeypatch.setenv("FASTMCP_SERVER_DEFAULT_AUTH_PROVIDER", "bearer_env")
+    monkeypatch.setenv("FASTMCP_AUTH_BEARER_JWKS_URI", "test-jwks-uri")
+
+    mcp = FastMCP()
+    assert isinstance(mcp.auth, EnvBearerAuthProvider)
+    assert mcp.auth.jwks_uri == "test-jwks-uri"
+
+
+def test_configure_bearer_env_public_key_and_jwks_uri_error(monkeypatch):
+    monkeypatch.setenv("FASTMCP_SERVER_DEFAULT_AUTH_PROVIDER", "bearer_env")
+    monkeypatch.setenv("FASTMCP_AUTH_BEARER_PUBLIC_KEY", "test-public-key")
+    monkeypatch.setenv("FASTMCP_AUTH_BEARER_JWKS_URI", "test-jwks-uri")
+
+    with pytest.raises(ValueError, match="Provide either public_key or jwks_uri"):
+        FastMCP()
+
+
+def test_provided_auth_takes_precedence_over_env_vars(monkeypatch):
+    monkeypatch.setenv("FASTMCP_SERVER_DEFAULT_AUTH_PROVIDER", "bearer_env")
+    monkeypatch.setenv("FASTMCP_AUTH_BEARER_PUBLIC_KEY", "test-public-key")
+
+    mcp = FastMCP(auth=BearerAuthProvider(public_key="test-public-key-2"))
+    assert isinstance(mcp.auth, BearerAuthProvider)
+    assert not isinstance(mcp.auth, EnvBearerAuthProvider)
+    assert mcp.auth.public_key == "test-public-key-2"

tests/auth/test_oauth_client.py

@@ -0,0 +1,265 @@
+from collections.abc import Generator
+from unittest.mock import patch
+from urllib.parse import parse_qs, urlparse
+
+import httpx
+import pytest
+
+import fastmcp.client.auth  # Import module, not the function directly
+from fastmcp.client import Client
+from fastmcp.client.transports import StreamableHttpTransport
+from fastmcp.server.auth.auth import ClientRegistrationOptions
+from fastmcp.server.auth.providers.in_memory import InMemoryOAuthProvider
+from fastmcp.server.server import FastMCP
+from fastmcp.utilities.tests import run_server_in_process
+
+
+def fastmcp_server(issuer_url: str):
+    """Create a FastMCP server with OAuth authentication."""
+    server = FastMCP(
+        "TestServer",
+        auth=InMemoryOAuthProvider(
+            issuer_url=issuer_url,
+            client_registration_options=ClientRegistrationOptions(enabled=True),
+        ),
+    )
+
+    @server.tool()
+    def add(a: int, b: int) -> int:
+        """Add two numbers together."""
+        return a + b
+
+    @server.resource("resource://test")
+    def get_test_resource() -> str:
+        """Get a test resource."""
+        return "Hello from authenticated resource!"
+
+    return server
+
+
+def run_server(host: str, port: int, **kwargs) -> None:
+    fastmcp_server(f"http://{host}:{port}").run(host=host, port=port, **kwargs)
+
+
+@pytest.fixture(scope="module")
+def streamable_http_server() -> Generator[str, None, None]:
+    with run_server_in_process(run_server, transport="streamable-http") as url:
+        yield f"{url}/mcp"
+
+
+@pytest.fixture()
+def client_unauthorized(streamable_http_server: str) -> Client:
+    return Client(transport=StreamableHttpTransport(streamable_http_server))
+
+
+class HeadlessOAuthProvider(httpx.Auth):
+    """
+    OAuth provider that bypasses browser interaction for testing.
+
+    This simulates the complete OAuth flow programmatically by:
+    1. Discovering OAuth metadata from the server
+    2. Registering a client
+    3. Getting an authorization code (simulates user approval)
+    4. Exchanging it for an access token
+    5. Adding Bearer token to all requests
+
+    This enables testing OAuth-protected FastMCP servers without
+    requiring browser interaction or external OAuth providers.
+    """
+
+    def __init__(self, mcp_url: str):
+        self.mcp_url = mcp_url
+        parsed_url = urlparse(mcp_url)
+        self.server_base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
+        self._access_token = None
+
+    async def async_auth_flow(self, request):
+        """httpx.Auth interface - add Bearer token to requests."""
+        if not self._access_token:
+            await self._obtain_token()
+
+        if self._access_token:
+            request.headers["Authorization"] = f"Bearer {self._access_token}"
+
+        yield request
+
+    async def _obtain_token(self):
+        """Get a valid access token by simulating the OAuth flow."""
+        import base64
+        import hashlib
+        import secrets
+
+        from mcp.shared.auth import OAuthClientInformationFull
+        from pydantic import AnyHttpUrl
+
+        # Generate PKCE challenge/verifier
+        code_verifier = (
+            base64.urlsafe_b64encode(secrets.token_bytes(32)).decode().rstrip("=")
+        )
+        code_challenge = (
+            base64.urlsafe_b64encode(hashlib.sha256(code_verifier.encode()).digest())
+            .decode()
+            .rstrip("=")
+        )
+
+        # Create HTTP client to talk to the server
+        async with httpx.AsyncClient() as http_client:
+            # 1. Discover OAuth metadata
+            metadata_url = (
+                f"{self.server_base_url}/.well-known/oauth-authorization-server"
+            )
+            response = await http_client.get(metadata_url)
+            response.raise_for_status()
+            metadata = response.json()
+
+            # 2. Register a client
+            client_info = OAuthClientInformationFull(
+                client_id="test_client_headless",
+                client_secret="test_secret_headless",
+                redirect_uris=[AnyHttpUrl("http://localhost:8080/callback")],
+            )
+
+            register_response = await http_client.post(
+                metadata["registration_endpoint"],
+                json=client_info.model_dump(mode="json"),
+            )
+            register_response.raise_for_status()
+            registered_client = register_response.json()
+
+            # 3. Get authorization code (simulate user approval)
+            auth_params = {
+                "response_type": "code",
+                "client_id": registered_client["client_id"],
+                "redirect_uri": "http://localhost:8080/callback",
+                "code_challenge": code_challenge,
+                "code_challenge_method": "S256",
+                "state": "test_state_headless",
+            }
+
+            auth_response = await http_client.get(
+                metadata["authorization_endpoint"],
+                params=auth_params,
+                follow_redirects=False,
+            )
+
+            # Extract auth code from redirect
+            if auth_response.status_code == 302:
+                redirect_url = auth_response.headers["location"]
+                parsed = urlparse(redirect_url)
+                query_params = parse_qs(parsed.query)
+
+                if "error" in query_params:
+                    error = query_params["error"][0]
+                    error_desc = query_params.get(
+                        "error_description", ["Unknown error"]
+                    )[0]
+                    raise RuntimeError(
+                        f"OAuth authorization failed: {error} - {error_desc}"
+                    )
+
+                auth_code = query_params["code"][0]
+
+                # 4. Exchange auth code for access token
+                token_data = {
+                    "grant_type": "authorization_code",
+                    "client_id": registered_client["client_id"],
+                    "client_secret": registered_client["client_secret"],
+                    "code": auth_code,
+                    "redirect_uri": "http://localhost:8080/callback",
+                    "code_verifier": code_verifier,
+                }
+
+                token_response = await http_client.post(
+                    metadata["token_endpoint"], data=token_data
+                )
+                token_response.raise_for_status()
+                token_info = token_response.json()
+
+                self._access_token = token_info["access_token"]
+            else:
+                raise RuntimeError(f"Authorization failed: {auth_response.status_code}")
+
+
+@pytest.fixture()
+def client_with_headless_oauth(
+    streamable_http_server: str,
+) -> Generator[Client, None, None]:
+    """Client with headless OAuth that bypasses browser interaction."""
+
+    # Patch the OAuth function to return our headless provider
+    def headless_oauth(*args, **kwargs):
+        mcp_url = args[0] if args else kwargs.get("mcp_url", "")
+        if not mcp_url:
+            raise ValueError("mcp_url is required")
+        return HeadlessOAuthProvider(mcp_url)
+
+    with patch("fastmcp.client.auth.OAuth", side_effect=headless_oauth):
+        client = Client(
+            transport=StreamableHttpTransport(streamable_http_server),
+            auth=fastmcp.client.auth.OAuth(mcp_url=streamable_http_server),
+        )
+        yield client
+
+
+async def test_unauthorized(client_unauthorized: Client):
+    """Test that unauthenticated requests are rejected."""
+    with pytest.raises(httpx.HTTPStatusError, match="401 Unauthorized"):
+        async with client_unauthorized:
+            pass
+
+
+async def test_ping(client_with_headless_oauth: Client):
+    """Test that we can ping the server."""
+    async with client_with_headless_oauth:
+        assert await client_with_headless_oauth.ping()
+
+
+async def test_list_tools(client_with_headless_oauth: Client):
+    """Test that we can list tools."""
+    async with client_with_headless_oauth:
+        tools = await client_with_headless_oauth.list_tools()
+        tool_names = [tool.name for tool in tools]
+        assert "add" in tool_names
+
+
+async def test_call_tool(client_with_headless_oauth: Client):
+    """Test that we can call a tool."""
+    async with client_with_headless_oauth:
+        result = await client_with_headless_oauth.call_tool("add", {"a": 5, "b": 3})
+        assert result[0].text == "8"  # type: ignore[attr-defined]
+
+
+async def test_list_resources(client_with_headless_oauth: Client):
+    """Test that we can list resources."""
+    async with client_with_headless_oauth:
+        resources = await client_with_headless_oauth.list_resources()
+        resource_uris = [str(resource.uri) for resource in resources]
+        assert "resource://test" in resource_uris
+
+
+async def test_read_resource(client_with_headless_oauth: Client):
+    """Test that we can read a resource."""
+    async with client_with_headless_oauth:
+        resource = await client_with_headless_oauth.read_resource("resource://test")
+        assert resource[0].text == "Hello from authenticated resource!"  # type: ignore[attr-defined]
+
+
+async def test_oauth_server_metadata_discovery(streamable_http_server: str):
+    """Test that we can discover OAuth metadata from the running server."""
+    parsed_url = urlparse(streamable_http_server)
+    server_base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
+
+    async with httpx.AsyncClient() as client:
+        # Test OAuth discovery endpoint
+        metadata_url = f"{server_base_url}/.well-known/oauth-authorization-server"
+        response = await client.get(metadata_url)
+        assert response.status_code == 200
+
+        metadata = response.json()
+        assert "authorization_endpoint" in metadata
+        assert "token_endpoint" in metadata
+        assert "registration_endpoint" in metadata
+
+        # The endpoints should be properly formed URLs
+        assert metadata["authorization_endpoint"].startswith(server_base_url)
+        assert metadata["token_endpoint"].startswith(server_base_url)

tests/client/__init__.py

@@ -1 +0,0 @@
-"""Client tests package."""

tests/client/test_client.py

@@ -16,7 +16,6 @@ from fastmcp.client.transports import (
     infer_transport,
 )
 from fastmcp.exceptions import ResourceError, ToolError
-from fastmcp.prompts.prompt import TextContent
 from fastmcp.server.server import FastMCP
 
 
@@ -201,8 +200,7 @@ async def test_get_prompt(fastmcp_server):
         result = await client.get_prompt("welcome", {"name": "Developer"})
 
         # The result should contain our welcome message
-        assert isinstance(result.messages[0].content, TextContent)
-        assert result.messages[0].content.text == "Welcome to FastMCP, Developer!"
+        assert result.messages[0].content.text == "Welcome to FastMCP, Developer!"  # type: ignore[attr-defined]
         assert result.description == "Example greeting prompt."
 
 
@@ -214,8 +212,7 @@ async def test_get_prompt_mcp(fastmcp_server):
         result = await client.get_prompt_mcp("welcome", {"name": "Developer"})
 
         # The result should contain our welcome message
-        assert isinstance(result.messages[0].content, TextContent)
-        assert result.messages[0].content.text == "Welcome to FastMCP, Developer!"
+        assert result.messages[0].content.text == "Welcome to FastMCP, Developer!"  # type: ignore[attr-defined]
         assert result.description == "Example greeting prompt."
 
 
@@ -342,6 +339,52 @@ async def test_client_nested_context_manager(fastmcp_server):
     assert client._session is None
 
 
+async def test_concurrent_client_context_managers():
+    """
+    Test that concurrent client usage doesn't cause cross-task cancel scope issues.
+    https://github.com/jlowin/fastmcp/pull/643
+    """
+    # Create a simple server
+    server = FastMCP("Test Server")
+
+    @server.tool()
+    def echo(text: str) -> str:
+        """Echo tool"""
+        return text
+
+    # Create client
+    client = Client(server)
+
+    # Track results
+    results = {}
+    errors = []
+
+    async def use_client(task_id: str, delay: float = 0):
+        """Use the client with a small delay to ensure overlap"""
+        try:
+            async with client:
+                # Add a small delay to ensure contexts overlap
+                await asyncio.sleep(delay)
+                # Make an actual call to exercise the session
+                tools = await client.list_tools()
+                results[task_id] = len(tools)
+        except Exception as e:
+            errors.append((task_id, str(e)))
+
+    # Run multiple tasks concurrently
+    # The key is having them enter and exit the context at different times
+    await asyncio.gather(
+        use_client("task1", 0.0),
+        use_client("task2", 0.01),  # Slight delay to ensure overlap
+        use_client("task3", 0.02),
+        return_exceptions=False,
+    )
+
+    assert len(errors) == 0, f"Errors occurred: {errors}"
+    assert len(results) == 3
+    assert all(count == 1 for count in results.values())  # All should see 1 tool
+
+
 async def test_resource_template(fastmcp_server):
     """Test using a resource template with InMemoryClient."""
     client = Client(transport=FastMCPTransport(fastmcp_server))
@@ -476,9 +519,8 @@ class TestErrorHandling:
         async with client:
             result = await client.call_tool_mcp("error_tool", {})
             assert result.isError
-            assert isinstance(result.content[0], TextContent)
-            assert "test error" in result.content[0].text
-            assert "abc" in result.content[0].text
+            assert "test error" in result.content[0].text  # type: ignore[attr-defined]
+            assert "abc" in result.content[0].text  # type: ignore[attr-defined]
 
     async def test_general_tool_exceptions_are_masked_when_enabled(self):
         mcp = FastMCP("TestServer", mask_error_details=True)
@@ -492,9 +534,8 @@ class TestErrorHandling:
         async with client:
             result = await client.call_tool_mcp("error_tool", {})
             assert result.isError
-            assert isinstance(result.content[0], TextContent)
-            assert "test error" not in result.content[0].text
-            assert "abc" not in result.content[0].text
+            assert "test error" not in result.content[0].text  # type: ignore[attr-defined]
+            assert "abc" not in result.content[0].text  # type: ignore[attr-defined]
 
     async def test_specific_tool_errors_are_sent_to_client(self):
         mcp = FastMCP("TestServer")
@@ -508,9 +549,8 @@ class TestErrorHandling:
         async with client:
             result = await client.call_tool_mcp("custom_error_tool", {})
             assert result.isError
-            assert isinstance(result.content[0], TextContent)
-            assert "test error" in result.content[0].text
-            assert "abc" in result.content[0].text
+            assert "test error" in result.content[0].text  # type: ignore[attr-defined]
+            assert "abc" in result.content[0].text  # type: ignore[attr-defined]
 
     async def test_general_resource_exceptions_are_not_masked_by_default(self):
         mcp = FastMCP("TestServer")

tests/client/test_openapi.py

@@ -1,11 +1,8 @@
 import json
-import sys
 from collections.abc import Generator
 
 import pytest
-import uvicorn
 from fastapi import FastAPI, Request
-from mcp.types import TextContent, TextResourceContents
 
 from fastmcp import Client, FastMCP
 from fastmcp.client.transports import SSETransport, StreamableHttpTransport
@@ -35,75 +32,34 @@ def fastmcp_server_for_headers() -> FastMCP:
     return mcp
 
 
-class TestClientHeaders:
-    def run_shttp_server(self, host: str, port: int) -> None:
-        try:
-            app = fastmcp_server_for_headers().http_app(transport="streamable-http")
-            server = uvicorn.Server(
-                config=uvicorn.Config(
-                    app=app,
-                    host=host,
-                    port=port,
-                    log_level="error",
-                    lifespan="on",
-                )
-            )
-            server.run()
-        except Exception as e:
-            print(f"Server error: {e}")
-            sys.exit(1)
-        sys.exit(0)
-
-    def run_sse_server(self, host: str, port: int) -> None:
-        try:
-            app = fastmcp_server_for_headers().http_app(transport="sse")
-            server = uvicorn.Server(
-                config=uvicorn.Config(
-                    app=app,
-                    host=host,
-                    port=port,
-                    log_level="error",
-                    lifespan="on",
-                )
-            )
-            server.run()
-        except Exception as e:
-            print(f"Server error: {e}")
-            sys.exit(1)
-        sys.exit(0)
-
-    def run_proxy_server(self, host: str, port: int, remote_url: str) -> None:
-        try:
-            client = Client(transport=StreamableHttpTransport(remote_url))
-            app = FastMCP.as_proxy(client).http_app(transport="streamable-http")
-            server = uvicorn.Server(
-                config=uvicorn.Config(
-                    app=app,
-                    host=host,
-                    port=port,
-                    log_level="error",
-                    lifespan="on",
-                )
-            )
-            server.run()
-        except Exception as e:
-            print(f"Server error: {e}")
-            sys.exit(1)
-        sys.exit(0)
+def run_server(host: str, port: int, **kwargs) -> None:
+    fastmcp_server_for_headers().run(host=host, port=port, **kwargs)
 
+
+def run_proxy_server(host: str, port: int, shttp_url: str, **kwargs) -> None:
+    client = Client(transport=StreamableHttpTransport(shttp_url))
+    app = FastMCP.as_proxy(client)
+    app.run(host=host, port=port, **kwargs)
+
+
+class TestClientHeaders:
     @pytest.fixture(scope="class")
     def shttp_server(self) -> Generator[str, None, None]:
-        with run_server_in_process(self.run_shttp_server) as url:
+        with run_server_in_process(run_server, transport="streamable-http") as url:
             yield f"{url}/mcp"
 
     @pytest.fixture(scope="class")
     def sse_server(self) -> Generator[str, None, None]:
-        with run_server_in_process(self.run_sse_server) as url:
+        with run_server_in_process(run_server, transport="sse") as url:
             yield f"{url}/sse"
 
     @pytest.fixture(scope="class")
     def proxy_server(self, shttp_server: str) -> Generator[str, None, None]:
-        with run_server_in_process(self.run_proxy_server, shttp_server + "/mcp") as url:
+        with run_server_in_process(
+            run_proxy_server,
+            shttp_url=shttp_server,
+            transport="streamable-http",
+        ) as url:
             yield f"{url}/mcp"
 
     async def test_client_headers_sse_resource(self, sse_server: str):
@@ -111,8 +67,7 @@ class TestClientHeaders:
             transport=SSETransport(sse_server, headers={"X-TEST": "test-123"})
         ) as client:
             result = await client.read_resource("resource://get_headers_headers_get")
-            assert isinstance(result[0], TextResourceContents)
-            headers = json.loads(result[0].text)
+            headers = json.loads(result[0].text)  # type: ignore[attr-defined]
             assert headers["x-test"] == "test-123"
 
     async def test_client_headers_shttp_resource(self, shttp_server: str):
@@ -122,8 +77,7 @@ class TestClientHeaders:
             )
         ) as client:
             result = await client.read_resource("resource://get_headers_headers_get")
-            assert isinstance(result[0], TextResourceContents)
-            headers = json.loads(result[0].text)
+            headers = json.loads(result[0].text)  # type: ignore[attr-defined]
             assert headers["x-test"] == "test-123"
 
     async def test_client_headers_sse_resource_template(self, sse_server: str):
@@ -133,8 +87,7 @@ class TestClientHeaders:
             result = await client.read_resource(
                 "resource://get_header_by_name_headers/x-test"
             )
-            assert isinstance(result[0], TextResourceContents)
-            header = json.loads(result[0].text)
+            header = json.loads(result[0].text)  # type: ignore[attr-defined]
             assert header == "test-123"
 
     async def test_client_headers_shttp_resource_template(self, shttp_server: str):
@@ -146,8 +99,7 @@ class TestClientHeaders:
             result = await client.read_resource(
                 "resource://get_header_by_name_headers/x-test"
             )
-            assert isinstance(result[0], TextResourceContents)
-            header = json.loads(result[0].text)
+            header = json.loads(result[0].text)  # type: ignore[attr-defined]
             assert header == "test-123"
 
     async def test_client_headers_sse_tool(self, sse_server: str):
@@ -155,8 +107,7 @@ class TestClientHeaders:
             transport=SSETransport(sse_server, headers={"X-TEST": "test-123"})
         ) as client:
             result = await client.call_tool("post_headers_headers_post")
-            assert isinstance(result[0], TextContent)
-            headers = json.loads(result[0].text)
+            headers = json.loads(result[0].text)  # type: ignore[attr-defined]
             assert headers["x-test"] == "test-123"
 
     async def test_client_headers_shttp_tool(self, shttp_server: str):
@@ -166,8 +117,7 @@ class TestClientHeaders:
             )
         ) as client:
             result = await client.call_tool("post_headers_headers_post")
-            assert isinstance(result[0], TextContent)
-            headers = json.loads(result[0].text)
+            headers = json.loads(result[0].text)  # type: ignore[attr-defined]
             assert headers["x-test"] == "test-123"
 
     async def test_client_overrides_server_headers(self, shttp_server: str):
@@ -177,8 +127,7 @@ class TestClientHeaders:
             )
         ) as client:
             result = await client.read_resource("resource://get_headers_headers_get")
-            assert isinstance(result[0], TextResourceContents)
-            headers = json.loads(result[0].text)
+            headers = json.loads(result[0].text)  # type: ignore[attr-defined]
             assert headers["x-server-header"] == "test-client"
 
     async def test_client_with_excluded_header_is_ignored(self, sse_server: str):
@@ -193,8 +142,7 @@ class TestClientHeaders:
             )
         ) as client:
             result = await client.read_resource("resource://get_headers_headers_get")
-            assert isinstance(result[0], TextResourceContents)
-            headers = json.loads(result[0].text)
+            headers = json.loads(result[0].text)  # type: ignore[attr-defined]
             assert headers["not-host"] == "1.2.3.4"
             assert headers["host"] == "fastapi"
 
@@ -204,6 +152,5 @@ class TestClientHeaders:
         """
         async with Client(transport=StreamableHttpTransport(proxy_server)) as client:
             result = await client.read_resource("resource://get_headers_headers_get")
-            assert isinstance(result[0], TextResourceContents)
-            headers = json.loads(result[0].text)
+            headers = json.loads(result[0].text)  # type: ignore[attr-defined]
             assert headers["x-server-header"] == "test-abc"

tests/client/test_roots.py

@@ -1,7 +1,6 @@
 import json
 
 import pytest
-from mcp.types import TextContent
 
 from fastmcp import Client, Context, FastMCP
 
@@ -41,8 +40,7 @@ class TestClientRoots:
     async def test_valid_roots(self, fastmcp_server: FastMCP, roots: list[str]):
         async with Client(fastmcp_server, roots=roots) as client:
             result = await client.call_tool("list_roots", {})
-            assert isinstance(result[0], TextContent)
-            assert json.loads(result[0].text) == [
+            assert json.loads(result[0].text) == [  # type: ignore[attr-defined]
                 "file://x/y/z",
                 "file://x/y/z",
             ]

tests/client/test_sse.py

@@ -6,7 +6,6 @@ from collections.abc import Generator
 import pytest
 import uvicorn
 from mcp import McpError
-from mcp.types import TextResourceContents
 from starlette.applications import Starlette
 from starlette.routing import Mount
 
@@ -64,22 +63,13 @@ def fastmcp_server():
     return server
 
 
-def run_server(host: str, port: int, path: str | None = None) -> None:
-    try:
-        app = fastmcp_server().http_app(transport="sse", path=path)
-        server = uvicorn.Server(
-            config=uvicorn.Config(app=app, host=host, port=port, log_level="error")
-        )
-        server.run()
-    except Exception as e:
-        print(f"Server error: {e}")
-        sys.exit(1)
-    sys.exit(0)
+def run_server(host: str, port: int, **kwargs) -> None:
+    fastmcp_server().run(host=host, port=port, **kwargs)
 
 
 @pytest.fixture(autouse=True, scope="module")
 def sse_server() -> Generator[str, None, None]:
-    with run_server_in_process(run_server) as url:
+    with run_server_in_process(run_server, transport="sse") as url:
         yield f"{url}/sse"
 
 
@@ -96,29 +86,23 @@ async def test_http_headers(sse_server: str):
         transport=SSETransport(sse_server, headers={"X-DEMO-HEADER": "ABC"})
     ) as client:
         raw_result = await client.read_resource("request://headers")
-        assert isinstance(raw_result[0], TextResourceContents)
-        json_result = json.loads(raw_result[0].text)
+        json_result = json.loads(raw_result[0].text)  # type: ignore[attr-defined]
         assert "x-demo-header" in json_result
         assert json_result["x-demo-header"] == "ABC"
 
 
 def run_nested_server(host: str, port: int) -> None:
-    try:
-        app = fastmcp_server().sse_app(path="/mcp/sse", message_path="/mcp/messages")
-        mount = Starlette(routes=[Mount("/nest-inner", app=app)])
-        mount2 = Starlette(routes=[Mount("/nest-outer", app=mount)])
-        server = uvicorn.Server(
-            config=uvicorn.Config(app=mount2, host=host, port=port, log_level="error")
-        )
-        server.run()
-    except Exception as e:
-        print(f"Server error: {e}")
-        sys.exit(1)
-    sys.exit(0)
+    app = fastmcp_server().sse_app(path="/mcp/sse", message_path="/mcp/messages")
+    mount = Starlette(routes=[Mount("/nest-inner", app=app)])
+    mount2 = Starlette(routes=[Mount("/nest-outer", app=mount)])
+    server = uvicorn.Server(
+        config=uvicorn.Config(app=mount2, host=host, port=port, log_level="error")
+    )
+    server.run()
 
 
 async def test_run_server_on_path():
-    with run_server_in_process(run_server, "/help") as url:
+    with run_server_in_process(run_server, transport="sse", path="/help") as url:
         async with Client(transport=SSETransport(f"{url}/help")) as client:
             result = await client.ping()
             assert result is True

tests/client/test_stdio.py

@@ -1,7 +1,6 @@
 import inspect
 
 import pytest
-from mcp.types import TextContent
 
 from fastmcp import Client
 from fastmcp.client.transports import PythonStdioTransport, StdioTransport
@@ -49,13 +48,11 @@ class TestKeepAlive:
 
         async with client:
             result1 = await client.call_tool("pid")
-            assert isinstance(result1[0], TextContent)
-            pid1 = int(result1[0].text)
+            pid1 = int(result1[0].text)  # type: ignore[attr-defined]
 
         async with client:
             result2 = await client.call_tool("pid")
-            assert isinstance(result2[0], TextContent)
-            pid2 = int(result2[0].text)
+            pid2 = int(result2[0].text)  # type: ignore[attr-defined]
 
         assert pid1 == pid2
 
@@ -69,13 +66,11 @@ class TestKeepAlive:
 
         async with client:
             result1 = await client.call_tool("pid")
-            assert isinstance(result1[0], TextContent)
-            pid1 = int(result1[0].text)
+            pid1 = int(result1[0].text)  # type: ignore[attr-defined]
 
         async with client:
             result2 = await client.call_tool("pid")
-            assert isinstance(result2[0], TextContent)
-            pid2 = int(result2[0].text)
+            pid2 = int(result2[0].text)  # type: ignore[attr-defined]
 
         assert pid1 != pid2
 
@@ -85,15 +80,13 @@ class TestKeepAlive:
 
         async with client:
             result1 = await client.call_tool("pid")
-            assert isinstance(result1[0], TextContent)
-            pid1 = int(result1[0].text)
+            pid1 = int(result1[0].text)  # type: ignore[attr-defined]
 
         await client.close()
 
         async with client:
             result2 = await client.call_tool("pid")
-            assert isinstance(result2[0], TextContent)
-            pid2 = int(result2[0].text)
+            pid2 = int(result2[0].text)  # type: ignore[attr-defined]
 
         assert pid1 != pid2
 
@@ -103,17 +96,14 @@ class TestKeepAlive:
 
         async with client:
             result1 = await client.call_tool("pid")
-            assert isinstance(result1[0], TextContent)
-            pid1 = int(result1[0].text)
+            pid1 = int(result1[0].text)  # type: ignore[attr-defined]
 
             async with client:
                 result2 = await client.call_tool("pid")
-                assert isinstance(result2[0], TextContent)
-                pid2 = int(result2[0].text)
+                pid2 = int(result2[0].text)  # type: ignore[attr-defined]
 
             result3 = await client.call_tool("pid")
-            assert isinstance(result3[0], TextContent)
-            pid3 = int(result3[0].text)
+            pid3 = int(result3[0].text)  # type: ignore[attr-defined]
 
         assert pid1 == pid2 == pid3
 

tests/client/test_streamable_http.py

@@ -6,7 +6,6 @@ from collections.abc import Generator
 import pytest
 import uvicorn
 from mcp import McpError
-from mcp.types import TextResourceContents
 from starlette.applications import Starlette
 from starlette.routing import Mount
 
@@ -64,28 +63,33 @@ def fastmcp_server():
     return server
 
 
-def run_server(host: str, port: int) -> None:
-    try:
-        app = fastmcp_server().http_app()
-        server = uvicorn.Server(
-            config=uvicorn.Config(
-                app=app,
-                host=host,
-                port=port,
-                log_level="error",
-                lifespan="on",
-            )
+def run_server(host: str, port: int, **kwargs) -> None:
+    fastmcp_server().run(host=host, port=port, **kwargs)
+
+
+def run_nested_server(host: str, port: int) -> None:
+    mcp_app = fastmcp_server().http_app(path="/final/mcp")
+
+    mount = Starlette(routes=[Mount("/nest-inner", app=mcp_app)])
+    mount2 = Starlette(
+        routes=[Mount("/nest-outer", app=mount)],
+        lifespan=mcp_app.lifespan,
+    )
+    server = uvicorn.Server(
+        config=uvicorn.Config(
+            app=mount2,
+            host=host,
+            port=port,
+            log_level="error",
+            lifespan="on",
         )
-        server.run()
-    except Exception as e:
-        print(f"Server error: {e}")
-        sys.exit(1)
-    sys.exit(0)
+    )
+    server.run()
 
 
 @pytest.fixture(scope="module")
 def streamable_http_server() -> Generator[str, None, None]:
-    with run_server_in_process(run_server) as url:
+    with run_server_in_process(run_server, transport="streamable-http") as url:
         yield f"{url}/mcp"
 
 
@@ -106,37 +110,11 @@ async def test_http_headers(streamable_http_server: str):
         )
     ) as client:
         raw_result = await client.read_resource("request://headers")
-        assert isinstance(raw_result[0], TextResourceContents)
-        json_result = json.loads(raw_result[0].text)
+        json_result = json.loads(raw_result[0].text)  # type: ignore[attr-defined]
         assert "x-demo-header" in json_result
         assert json_result["x-demo-header"] == "ABC"
 
 
-def run_nested_server(host: str, port: int) -> None:
-    try:
-        mcp_app = fastmcp_server().http_app(path="/final/mcp")
-
-        mount = Starlette(routes=[Mount("/nest-inner", app=mcp_app)])
-        mount2 = Starlette(
-            routes=[Mount("/nest-outer", app=mount)],
-            lifespan=mcp_app.lifespan,
-        )
-        server = uvicorn.Server(
-            config=uvicorn.Config(
-                app=mount2,
-                host=host,
-                port=port,
-                log_level="error",
-                lifespan="on",
-            )
-        )
-        server.run()
-    except Exception as e:
-        print(f"Server error: {e}")
-        sys.exit(1)
-    sys.exit(0)
-
-
 async def test_nested_streamable_http_server_resolves_correctly():
     # tests patch for
     # https://github.com/modelcontextprotocol/python-sdk/pull/659

tests/prompts/test_prompt_manager.py

@@ -393,8 +393,7 @@ class TestContextHandling:
             messages = await prompt.render(arguments={"x": 42})
 
         assert len(messages) == 1
-        assert isinstance(messages[0].content, TextContent)
-        assert messages[0].content.text == "42"
+        assert messages[0].content.text == "42"  # type: ignore[attr-defined]
 
     async def test_context_optional(self):
         """Test that context is optional when rendering prompts."""
@@ -416,8 +415,7 @@ class TestContextHandling:
             )
 
         assert len(messages) == 1
-        assert isinstance(messages[0].content, TextContent)
-        assert messages[0].content.text == "42"
+        assert messages[0].content.text == "42"  # type: ignore[attr-defined]
 
     async def test_annotated_context_parameter_detection(self):
         """Test that annotated context parameters are properly detected in

tests/resources/test_file_resources.py

@@ -74,7 +74,6 @@ class TestFileResource:
             is_binary=True,
         )
         content = await resource.read()
-        assert isinstance(content, bytes)
         assert content == b"test content"
 
     def test_relative_path_error(self):

tests/server/http/test_http_dependencies.py

@@ -1,10 +1,7 @@
 import json
-import sys
 from collections.abc import Generator
 
 import pytest
-import uvicorn
-from mcp.types import TextContent, TextResourceContents
 
 from fastmcp.client import Client
 from fastmcp.client.transports import SSETransport, StreamableHttpTransport
@@ -41,53 +38,19 @@ def fastmcp_server():
     return server
 
 
-def run_shttp_server(host: str, port: int) -> None:
-    try:
-        app = fastmcp_server().http_app(transport="streamable-http")
-        server = uvicorn.Server(
-            config=uvicorn.Config(
-                app=app,
-                host=host,
-                port=port,
-                log_level="error",
-                lifespan="on",
-            )
-        )
-        server.run()
-    except Exception as e:
-        print(f"Server error: {e}")
-        sys.exit(1)
-    sys.exit(0)
-
-
-def run_sse_server(host: str, port: int) -> None:
-    try:
-        app = fastmcp_server().http_app(transport="sse")
-        server = uvicorn.Server(
-            config=uvicorn.Config(
-                app=app,
-                host=host,
-                port=port,
-                log_level="error",
-                lifespan="on",
-            )
-        )
-        server.run()
-    except Exception as e:
-        print(f"Server error: {e}")
-        sys.exit(1)
-    sys.exit(0)
+def run_server(host: str, port: int, **kwargs) -> None:
+    fastmcp_server().run(host=host, port=port, **kwargs)
 
 
 @pytest.fixture(autouse=True, scope="module")
 def shttp_server() -> Generator[str, None, None]:
-    with run_server_in_process(run_shttp_server) as url:
+    with run_server_in_process(run_server, transport="streamable-http") as url:
         yield f"{url}/mcp"
 
 
 @pytest.fixture(autouse=True, scope="module")
 def sse_server() -> Generator[str, None, None]:
-    with run_server_in_process(run_sse_server) as url:
+    with run_server_in_process(run_server, transport="sse") as url:
         yield f"{url}/sse"
 
 
@@ -99,8 +62,7 @@ async def test_http_headers_resource_shttp(shttp_server: str):
         )
     ) as client:
         raw_result = await client.read_resource("request://headers")
-        assert isinstance(raw_result[0], TextResourceContents)
-        json_result = json.loads(raw_result[0].text)
+        json_result = json.loads(raw_result[0].text)  # type: ignore[attr-defined]
         assert "x-demo-header" in json_result
         assert json_result["x-demo-header"] == "ABC"
 
@@ -111,8 +73,7 @@ async def test_http_headers_resource_sse(sse_server: str):
         transport=SSETransport(sse_server, headers={"X-DEMO-HEADER": "ABC"})
     ) as client:
         raw_result = await client.read_resource("request://headers")
-        assert isinstance(raw_result[0], TextResourceContents)
-        json_result = json.loads(raw_result[0].text)
+        json_result = json.loads(raw_result[0].text)  # type: ignore[attr-defined]
         assert "x-demo-header" in json_result
         assert json_result["x-demo-header"] == "ABC"
 
@@ -125,8 +86,7 @@ async def test_http_headers_tool_shttp(shttp_server: str):
         )
     ) as client:
         result = await client.call_tool("get_headers_tool")
-        assert isinstance(result[0], TextContent)
-        json_result = json.loads(result[0].text)
+        json_result = json.loads(result[0].text)  # type: ignore[attr-defined]
         assert "x-demo-header" in json_result
         assert json_result["x-demo-header"] == "ABC"
 
@@ -136,8 +96,7 @@ async def test_http_headers_tool_sse(sse_server: str):
         transport=SSETransport(sse_server, headers={"X-DEMO-HEADER": "ABC"})
     ) as client:
         result = await client.call_tool("get_headers_tool")
-        assert isinstance(result[0], TextContent)
-        json_result = json.loads(result[0].text)
+        json_result = json.loads(result[0].text)  # type: ignore[attr-defined]
         assert "x-demo-header" in json_result
         assert json_result["x-demo-header"] == "ABC"
 
@@ -150,8 +109,7 @@ async def test_http_headers_prompt_shttp(shttp_server: str):
         )
     ) as client:
         result = await client.get_prompt("get_headers_prompt")
-        assert isinstance(result.messages[0].content, TextContent)
-        json_result = json.loads(result.messages[0].content.text)
+        json_result = json.loads(result.messages[0].content.text)  # type: ignore[attr-defined]
         assert "x-demo-header" in json_result
         assert json_result["x-demo-header"] == "ABC"
 
@@ -162,7 +120,6 @@ async def test_http_headers_prompt_sse(sse_server: str):
         transport=SSETransport(sse_server, headers={"X-DEMO-HEADER": "ABC"})
     ) as client:
         result = await client.get_prompt("get_headers_prompt")
-        assert isinstance(result.messages[0].content, TextContent)
-        json_result = json.loads(result.messages[0].content.text)
+        json_result = json.loads(result.messages[0].content.text)  # type: ignore[attr-defined]
         assert "x-demo-header" in json_result
         assert json_result["x-demo-header"] == "ABC"

tests/server/openapi/test_openapi.py

@@ -9,7 +9,7 @@ from dirty_equals import IsStr
 from fastapi import FastAPI, HTTPException, Response
 from fastapi.responses import PlainTextResponse
 from httpx import ASGITransport, AsyncClient
-from mcp.types import BlobResourceContents, TextContent, TextResourceContents
+from mcp.types import BlobResourceContents
 from pydantic import BaseModel, TypeAdapter
 from pydantic.networks import AnyUrl
 
@@ -234,11 +234,7 @@ class TestTools:
                 "create_user_users_post", {"name": "David", "active": False}
             )
 
-        # Convert TextContent to dict for comparison
-        assert isinstance(tool_response, list) and len(tool_response) == 1
-        assert isinstance(tool_response[0], TextContent)
-
-        response_data = json.loads(tool_response[0].text)
+        response_data = json.loads(tool_response[0].text)  # type: ignore[attr-defined]
         expected_user = User(id=4, name="David", active=False).model_dump()
         assert response_data == expected_user
 
@@ -249,8 +245,7 @@ class TestTools:
         # Check that the user was created via MCP
         async with Client(fastmcp_openapi_server) as client:
             user_response = await client.read_resource("resource://get_user_users/4")
-            assert isinstance(user_response[0], TextResourceContents)
-            response_text = user_response[0].text
+            response_text = user_response[0].text  # type: ignore[attr-defined]
             user = json.loads(response_text)
         assert user == expected_user
 
@@ -266,11 +261,7 @@ class TestTools:
                 {"user_id": 1, "name": "XYZ"},
             )
 
-        # Convert TextContent to dict for comparison
-        assert isinstance(tool_response, list) and len(tool_response) == 1
-        assert isinstance(tool_response[0], TextContent)
-
-        response_data = json.loads(tool_response[0].text)
+        response_data = json.loads(tool_response[0].text)  # type: ignore[attr-defined]
         expected_data = dict(id=1, name="XYZ", active=True)
         assert response_data == expected_data
 
@@ -281,8 +272,7 @@ class TestTools:
         # Check that the user was updated via MCP
         async with Client(fastmcp_openapi_server) as client:
             user_response = await client.read_resource("resource://get_user_users/1")
-            assert isinstance(user_response[0], TextResourceContents)
-            response_text = user_response[0].text
+            response_text = user_response[0].text  # type: ignore[attr-defined]
             user = json.loads(response_text)
         assert user == expected_data
 
@@ -305,9 +295,7 @@ class TestTools:
         )
         async with Client(mcp_server) as client:
             tool_response = await client.call_tool("get_users_users_get", {})
-            assert isinstance(tool_response, list)
-            assert isinstance(tool_response[0], TextContent)
-            assert json.loads(tool_response[0].text) == [
+            assert json.loads(tool_response[0].text) == [  # type: ignore[attr-defined]
                 user.model_dump()
                 for user in sorted(users_db.values(), key=lambda x: x.id)
             ]
@@ -341,8 +329,7 @@ class TestResources:
             resource_response = await client.read_resource(
                 "resource://get_users_users_get"
             )
-            assert isinstance(resource_response[0], TextResourceContents)
-            response_text = resource_response[0].text
+            response_text = resource_response[0].text  # type: ignore[attr-defined]
             resource = json.loads(response_text)
         assert resource == json_users
         response = await api_client.get("/users")
@@ -369,8 +356,7 @@ class TestResources:
         """Test reading a resource that returns a string."""
         async with Client(fastmcp_openapi_server) as client:
             resource_response = await client.read_resource("resource://ping_ping_get")
-            assert isinstance(resource_response[0], TextResourceContents)
-            assert resource_response[0].text == "pong"
+            assert resource_response[0].text == "pong"  # type: ignore[attr-defined]
 
 
 class TestResourceTemplates:
@@ -407,8 +393,7 @@ class TestResourceTemplates:
             resource_response = await client.read_resource(
                 f"resource://get_user_users/{user_id}"
             )
-            assert isinstance(resource_response[0], TextResourceContents)
-            response_text = resource_response[0].text
+            response_text = resource_response[0].text  # type: ignore[attr-defined]
             resource = json.loads(response_text)
 
         assert resource == users_db[user_id].model_dump()
@@ -430,8 +415,7 @@ class TestResourceTemplates:
             resource_response = await client.read_resource(
                 f"resource://get_user_active_state_users/{is_active}/{user_id}"
             )
-            assert isinstance(resource_response[0], TextResourceContents)
-            response_text = resource_response[0].text
+            response_text = resource_response[0].text  # type: ignore[attr-defined]
             resource = json.loads(response_text)
 
         assert resource == users_db[user_id].model_dump()
@@ -681,8 +665,7 @@ class TestOpenAPI30Compatibility:
         """Test reading a resource from an OpenAPI 3.0 server."""
         async with Client(openapi_30_server) as client:
             resource_response = await client.read_resource("resource://listProducts")
-            assert isinstance(resource_response[0], TextResourceContents)
-            response_text = resource_response[0].text
+            response_text = resource_response[0].text  # type: ignore[attr-defined]
             content = json.loads(response_text)
         assert len(content) == 2
         assert content[0]["name"] == "Product 1"
@@ -692,8 +675,7 @@ class TestOpenAPI30Compatibility:
         """Test reading a resource from template from an OpenAPI 3.0 server."""
         async with Client(openapi_30_server) as client:
             resource_response = await client.read_resource("resource://getProduct/p1")
-            assert isinstance(resource_response[0], TextResourceContents)
-            response_text = resource_response[0].text
+            response_text = resource_response[0].text  # type: ignore[attr-defined]
             content = json.loads(response_text)
         assert content["id"] == "p1"
         assert content["name"] == "Product 1"
@@ -707,8 +689,7 @@ class TestOpenAPI30Compatibility:
             )
             # Result should be a text content
             assert len(result) == 1
-            assert isinstance(result[0], TextContent)
-            product = json.loads(result[0].text)
+            product = json.loads(result[0].text)  # type: ignore[attr-defined]
             assert product["id"] == "p3"
             assert product["name"] == "New Product"
             assert product["price"] == 39.99
@@ -857,8 +838,7 @@ class TestOpenAPI31Compatibility:
         """Test reading a resource from an OpenAPI 3.1 server."""
         async with Client(openapi_31_server) as client:
             resource_response = await client.read_resource("resource://listOrders")
-            assert isinstance(resource_response[0], TextResourceContents)
-            response_text = resource_response[0].text
+            response_text = resource_response[0].text  # type: ignore[attr-defined]
             content = json.loads(response_text)
         assert len(content) == 2
         assert content[0]["customer"] == "Alice"
@@ -868,8 +848,7 @@ class TestOpenAPI31Compatibility:
         """Test reading a resource from template from an OpenAPI 3.1 server."""
         async with Client(openapi_31_server) as client:
             resource_response = await client.read_resource("resource://getOrder/o1")
-            assert isinstance(resource_response[0], TextResourceContents)
-            response_text = resource_response[0].text
+            response_text = resource_response[0].text  # type: ignore[attr-defined]
             content = json.loads(response_text)
         assert content["id"] == "o1"
         assert content["customer"] == "Alice"
@@ -883,8 +862,7 @@ class TestOpenAPI31Compatibility:
             )
             # Result should be a text content
             assert len(result) == 1
-            assert isinstance(result[0], TextContent)
-            order = json.loads(result[0].text)
+            order = json.loads(result[0].text)  # type: ignore[attr-dict]
             assert order["id"] == "o3"
             assert order["customer"] == "Charlie"
             assert order["items"] == ["item4", "item5"]

tests/server/test_import_server.py

@@ -1,8 +1,6 @@
 import json
 from urllib.parse import quote
 
-from mcp.types import TextContent, TextResourceContents
-
 from fastmcp.client.client import Client
 from fastmcp.server.server import FastMCP
 
@@ -223,8 +221,7 @@ async def test_call_imported_custom_named_tool():
 
     async with Client(main_app) as client:
         result = await client.call_tool("api_get_data", {"query": "test"})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "Data for query: test"
+        assert result[0].text == "Data for query: test"  # type: ignore[attr-defined]
 
 
 async def test_first_level_importing_with_custom_name():
@@ -278,8 +275,7 @@ async def test_call_nested_imported_tool():
     result = await main_app._tool_manager.call_tool(
         "service_provider_compute", {"input": 21}
     )
-    assert isinstance(result[0], TextContent)
-    assert result[0].text == "42"
+    assert result[0].text == "42"  # type: ignore[attr-defined]
 
 
 async def test_import_with_proxy_tools():
@@ -302,8 +298,7 @@ async def test_import_with_proxy_tools():
     await main_app.import_server("api", proxy_app)
 
     result = await main_app._mcp_call_tool("api_get_data", {"query": "test"})
-    assert isinstance(result[0], TextContent)
-    assert result[0].text == "Data for query: test"
+    assert result[0].text == "Data for query: test"  # type: ignore[attr-defined]
 
 
 async def test_import_with_proxy_prompts():
@@ -326,8 +321,7 @@ async def test_import_with_proxy_prompts():
     await main_app.import_server("api", proxy_app)
 
     result = await main_app._mcp_get_prompt("api_greeting", {"name": "World"})
-    assert isinstance(result.messages[0].content, TextContent)
-    assert result.messages[0].content.text == "Hello, World from API!"
+    assert result.messages[0].content.text == "Hello, World from API!"  # type: ignore[attr-defined]
     assert result.description == "Example greeting prompt."
 
 
@@ -356,8 +350,7 @@ async def test_import_with_proxy_resources():
     # Access the resource through the main app with the prefixed key
     async with Client(main_app) as client:
         result = await client.read_resource("config://api/settings")
-        assert isinstance(result[0], TextResourceContents)
-        content = json.loads(result[0].text)
+        content = json.loads(result[0].text)  # type: ignore[attr-defined]
         assert content["api_key"] == "12345"
         assert content["base_url"] == "https://api.example.com"
 
@@ -387,8 +380,7 @@ async def test_import_with_proxy_resource_templates():
     quoted_email = quote("john@example.com", safe="")
     async with Client(main_app) as client:
         result = await client.read_resource(f"user://api/{quoted_name}/{quoted_email}")
-        assert isinstance(result[0], TextResourceContents)
-        content = json.loads(result[0].text)
+        content = json.loads(result[0].text)  # type: ignore[attr-defined]
         assert content["name"] == "John Doe"
         assert content["email"] == "john@example.com"
 

tests/server/test_lifespan.py

@@ -1,396 +0,0 @@
-"""Tests for lifespan functionality in both low-level and FastMCP servers."""
-
-import os
-import sys
-import traceback
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
-from pathlib import Path
-
-import anyio
-import httpx
-import uvicorn
-from mcp.server.lowlevel.server import NotificationOptions, Server
-from mcp.server.models import InitializationOptions
-from mcp.shared.message import SessionMessage
-from mcp.types import (
-    ClientCapabilities,
-    Implementation,
-    InitializeRequestParams,
-    JSONRPCMessage,
-    JSONRPCNotification,
-    JSONRPCRequest,
-)
-from pydantic import TypeAdapter
-from starlette.applications import Starlette
-from starlette.routing import Mount
-
-from fastmcp import Context, FastMCP
-from fastmcp.utilities.tests import run_server_in_process
-
-
-async def test_lowlevel_server_lifespan():
-    """Test that lifespan works in low-level server."""
-
-    @asynccontextmanager
-    async def test_lifespan(server: Server) -> AsyncIterator[dict[str, bool]]:
-        """Test lifespan context that tracks startup/shutdown."""
-        context = {"started": False, "shutdown": False}
-        try:
-            context["started"] = True
-            yield context
-        finally:
-            context["shutdown"] = True
-
-    server = Server("test", lifespan=test_lifespan)
-
-    # Create memory streams for testing
-    send_stream1, receive_stream1 = anyio.create_memory_object_stream(100)
-    send_stream2, receive_stream2 = anyio.create_memory_object_stream(100)
-
-    # Create a tool that accesses lifespan context
-    @server.call_tool()
-    async def check_lifespan(name: str, arguments: dict) -> list:
-        ctx = server.request_context
-        assert isinstance(ctx.lifespan_context, dict)
-        assert ctx.lifespan_context["started"]
-        assert not ctx.lifespan_context["shutdown"]
-        return [{"type": "text", "text": "true"}]
-
-    # Run server in background task
-    async with (
-        anyio.create_task_group() as tg,
-        send_stream1,
-        receive_stream1,
-        send_stream2,
-        receive_stream2,
-    ):
-
-        async def run_server():
-            await server.run(
-                receive_stream1,
-                send_stream2,
-                InitializationOptions(
-                    server_name="test",
-                    server_version="0.1.0",
-                    capabilities=server.get_capabilities(
-                        notification_options=NotificationOptions(),
-                        experimental_capabilities={},
-                    ),
-                ),
-                raise_exceptions=True,
-            )
-
-        tg.start_soon(run_server)
-
-        # Initialize the server
-        params = InitializeRequestParams(
-            protocolVersion="2024-11-05",
-            capabilities=ClientCapabilities(),
-            clientInfo=Implementation(name="test-client", version="0.1.0"),
-        )
-        await send_stream1.send(
-            SessionMessage(
-                JSONRPCMessage(
-                    root=JSONRPCRequest(
-                        jsonrpc="2.0",
-                        id=1,
-                        method="initialize",
-                        params=TypeAdapter(InitializeRequestParams).dump_python(params),
-                    )
-                )
-            )
-        )
-        response = await receive_stream2.receive()
-        response = response.message
-
-        # Send initialized notification
-        await send_stream1.send(
-            SessionMessage(
-                JSONRPCMessage(
-                    root=JSONRPCNotification(
-                        jsonrpc="2.0",
-                        method="notifications/initialized",
-                    )
-                )
-            )
-        )
-
-        # Call the tool to verify lifespan context
-        await send_stream1.send(
-            SessionMessage(
-                JSONRPCMessage(
-                    root=JSONRPCRequest(
-                        jsonrpc="2.0",
-                        id=2,
-                        method="tools/call",
-                        params={"name": "check_lifespan", "arguments": {}},
-                    )
-                )
-            )
-        )
-
-        # Get response and verify
-        response = await receive_stream2.receive()
-        response = response.message
-        assert response.root.result["content"][0]["text"] == "true"
-
-        # Cancel server task
-        tg.cancel_scope.cancel()
-
-
-async def test_fastmcp_server_lifespan():
-    """Test that lifespan works in FastMCP server."""
-
-    @asynccontextmanager
-    async def test_lifespan(server: FastMCP) -> AsyncIterator[dict]:
-        """Test lifespan context that tracks startup/shutdown."""
-        context = {"started": False, "shutdown": False}
-        try:
-            context["started"] = True
-            yield context
-        finally:
-            context["shutdown"] = True
-
-    server = FastMCP("test", lifespan=test_lifespan)
-
-    # Create memory streams for testing
-    send_stream1, receive_stream1 = anyio.create_memory_object_stream(100)
-    send_stream2, receive_stream2 = anyio.create_memory_object_stream(100)
-
-    # Add a tool that checks lifespan context
-    @server.tool()
-    def check_lifespan(ctx: Context) -> bool:
-        """Tool that checks lifespan context."""
-        assert isinstance(ctx.request_context.lifespan_context, dict)
-        assert ctx.request_context.lifespan_context["started"]
-        assert not ctx.request_context.lifespan_context["shutdown"]
-        return True
-
-    # Run server in background task
-    async with (
-        anyio.create_task_group() as tg,
-        send_stream1,
-        receive_stream1,
-        send_stream2,
-        receive_stream2,
-    ):
-
-        async def run_server():
-            await server._mcp_server.run(
-                receive_stream1,
-                send_stream2,
-                server._mcp_server.create_initialization_options(),
-                raise_exceptions=True,
-            )
-
-        tg.start_soon(run_server)
-
-        # Initialize the server
-        params = InitializeRequestParams(
-            protocolVersion="2024-11-05",
-            capabilities=ClientCapabilities(),
-            clientInfo=Implementation(name="test-client", version="0.1.0"),
-        )
-        await send_stream1.send(
-            SessionMessage(
-                JSONRPCMessage(
-                    root=JSONRPCRequest(
-                        jsonrpc="2.0",
-                        id=1,
-                        method="initialize",
-                        params=TypeAdapter(InitializeRequestParams).dump_python(params),
-                    )
-                )
-            )
-        )
-        response = await receive_stream2.receive()
-        response = response.message
-
-        # Send initialized notification
-        await send_stream1.send(
-            SessionMessage(
-                JSONRPCMessage(
-                    root=JSONRPCNotification(
-                        jsonrpc="2.0",
-                        method="notifications/initialized",
-                    )
-                )
-            )
-        )
-
-        # Call the tool to verify lifespan context
-        await send_stream1.send(
-            SessionMessage(
-                JSONRPCMessage(
-                    root=JSONRPCRequest(
-                        jsonrpc="2.0",
-                        id=2,
-                        method="tools/call",
-                        params={"name": "check_lifespan", "arguments": {}},
-                    )
-                )
-            )
-        )
-
-        # Get response and verify
-        response = await receive_stream2.receive()
-        response = response.message
-        assert response.root.result["content"][0]["text"] == "true"
-
-        # Cancel server task
-        tg.cancel_scope.cancel()
-
-
-def run_server_with_incorrect_lifespan_setup(
-    host: str, port: int, server_log_file_path: str
-) -> None:
-    os.makedirs(os.path.dirname(server_log_file_path), exist_ok=True)
-
-    CUSTOM_LOGGING_CONFIG = {
-        "version": 1,
-        "disable_existing_loggers": False,
-        "formatters": {
-            "default": {
-                "()": "uvicorn.logging.DefaultFormatter",
-                "fmt": "%(levelprefix)s %(asctime)s [%(name)s] %(message)s",
-                "datefmt": "%Y-%m-%d %H:%M:%S",
-                "use_colors": False,
-            },
-            "access": {
-                "()": "uvicorn.logging.AccessFormatter",
-                "fmt": '%(levelprefix)s %(asctime)s [%(name)s] %(client_addr)s - "%(request_line)s" %(status_code)s',
-                "datefmt": "%Y-%m-%d %H:%M:%S",
-                "use_colors": False,
-            },
-        },
-        "handlers": {
-            "file_default": {
-                "formatter": "default",
-                "class": "logging.FileHandler",
-                "filename": server_log_file_path,
-                "mode": "w",
-            },
-            "file_access": {
-                "formatter": "access",
-                "class": "logging.FileHandler",
-                "filename": server_log_file_path,
-                "mode": "a",
-            },
-        },
-        "loggers": {
-            "uvicorn": {  # Catches uvicorn root logs
-                "handlers": ["file_default"],
-                "level": "DEBUG",
-                "propagate": False,
-            },
-            "uvicorn.error": {
-                "handlers": ["file_default"],
-                "level": "DEBUG",
-                "propagate": False,
-            },
-            "uvicorn.access": {
-                "handlers": ["file_access"],
-                "level": "INFO",
-                "propagate": False,
-            },
-        },
-        "root": {
-            "handlers": ["file_default"],
-            "level": "DEBUG",
-        },
-    }
-
-    try:
-        mcp = FastMCP()
-
-        @mcp.tool("ping_tool", "A simple ping tool for the test server")
-        def ping_tool() -> str:
-            return "pong"
-
-        mcp_asgi_app = mcp.http_app(transport="streamable-http")
-
-        parent_app = Starlette(
-            routes=[Mount("/mounted_mcp", app=mcp_asgi_app)],
-        )
-
-        uvicorn.run(
-            parent_app,
-            host=host,
-            port=port,
-            log_config=CUSTOM_LOGGING_CONFIG,
-            log_level=None,
-        )
-        sys.exit(0)
-    except Exception as e_outer:
-        with open(server_log_file_path, "a") as f_fallback:
-            f_fallback.write(
-                "--- FALLBACK EXCEPTION IN SERVER RUNNER (PRE-UVICORN) ---\n"
-            )
-            f_fallback.write(f"{type(e_outer).__name__}: {e_outer}\n")
-            f_fallback.write(traceback.format_exc())
-        sys.exit(1)
-
-
-async def test_missing_lifespan_logs_informative_error(tmp_path: Path):
-    server_log_file = tmp_path / "server.log"
-
-    with run_server_in_process(
-        run_server_with_incorrect_lifespan_setup, str(server_log_file)
-    ) as server_url:
-        full_mcp_path = server_url + "/mounted_mcp/mcp/"
-
-        client_triggered_error = False
-        response_status = -1
-        response_body = ""
-        try:
-            async with httpx.AsyncClient(timeout=10) as client:
-                response = await client.post(
-                    full_mcp_path,
-                    json={"id": 1, "method": "list_tools", "jsonrpc": "2.0"},
-                )
-            response_status = response.status_code
-            response_body = response.text
-            if response.status_code == 500:
-                client_triggered_error = True
-            else:
-                print(
-                    f"Client received unexpected status code: {response.status_code} "
-                    f"Response: {response_body[:500]}"
-                )
-        except httpx.RequestError as e:
-            print(f"Client request failed with RequestError: {e}")
-            client_triggered_error = True
-
-        assert client_triggered_error, (
-            f"Client request did not result in a 500 error or a request error. "
-            f"Status: {response_status}, Body: {response_body[:500]}"
-        )
-
-    assert server_log_file.exists(), (
-        f"Server log file was not created at {server_log_file}"
-    )
-    log_content = server_log_file.read_text()
-
-    print(f"--- Captured Server Log Content ({server_log_file}) ---")
-    print(log_content)
-    print("--- End Server Log Content ---")
-
-    # Core assertions for the enhanced error message
-    assert (
-        "FastMCP's StreamableHTTPSessionManager task group was not initialized"
-        in log_content
-    )
-    assert "lifespan=mcp_app.lifespan" in log_content
-    assert "gofastmcp.com/deployment/asgi" in log_content
-    assert "Original error: Task group is not initialized" in log_content
-
-    # Check for Uvicorn's own error logging wrapper for the request
-    assert "ERROR" in log_content  # General check for ERROR level logs
-    assert "Exception in ASGI application" in log_content
-
-    # Sanity checks for server operation and logging setup
-    assert "Uvicorn running on" in log_content
-    assert (
-        "--- FALLBACK EXCEPTION IN SERVER RUNNER (PRE-UVICORN) ---" not in log_content
-    )

tests/server/test_logging.py

@@ -2,6 +2,7 @@ import asyncio
 import logging
 from unittest.mock import AsyncMock, Mock, patch
 
+import anyio
 import pytest
 
 from fastmcp.server.server import FastMCP
@@ -27,7 +28,7 @@ async def test_uvicorn_logging_default_level(
     """Tests that FastMCP passes log_level to uvicorn.Config if no log_config is given."""
     mock_server_instance = AsyncMock()
     mock_uvicorn_server_constructor.return_value = mock_server_instance
-    serve_finished_event = asyncio.Event()
+    serve_finished_event = anyio.Event()
     mock_server_instance.serve.side_effect = serve_finished_event.wait
 
     test_log_level = "warning"
@@ -63,7 +64,7 @@ async def test_uvicorn_logging_with_custom_log_config(
     """Tests that FastMCP passes log_config to uvicorn.Config and not log_level."""
     mock_server_instance = AsyncMock()
     mock_uvicorn_server_constructor.return_value = mock_server_instance
-    serve_finished_event = asyncio.Event()
+    serve_finished_event = anyio.Event()
     mock_server_instance.serve.side_effect = serve_finished_event.wait
 
     sample_log_config = {
@@ -123,7 +124,7 @@ async def test_uvicorn_logging_custom_log_config_overrides_log_level_param(
     """Tests log_config precedence if log_level is also passed to run_http_async."""
     mock_server_instance = AsyncMock()
     mock_uvicorn_server_constructor.return_value = mock_server_instance
-    serve_finished_event = asyncio.Event()
+    serve_finished_event = anyio.Event()
     mock_server_instance.serve.side_effect = serve_finished_event.wait
 
     sample_log_config = {

tests/server/test_mount.py

@@ -3,8 +3,6 @@ import sys
 from contextlib import asynccontextmanager
 
 import pytest
-from mcp.server.lowlevel.helper_types import ReadResourceContents
-from mcp.types import TextContent, TextResourceContents
 
 from fastmcp import FastMCP
 from fastmcp.client import Client
@@ -36,8 +34,7 @@ class TestBasicMount:
 
         async with Client(main_app) as client:
             result = await client.call_tool("sub_sub_tool", {})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "This is from the sub app"
+            assert result[0].text == "This is from the sub app"  # type: ignore[attr-defined]
 
     async def test_mount_with_custom_separator(self):
         """Test mounting with a custom tool separator (deprecated but still supported)."""
@@ -57,8 +54,7 @@ class TestBasicMount:
 
         # Call the tool
         result = await main_app._mcp_call_tool("sub_greet", {"name": "World"})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "Hello, World!"
+        assert result[0].text == "Hello, World!"  # type: ignore[attr-defined]
 
     async def test_mount_invalid_resource_prefix(self):
         main_app = FastMCP("MainApp")
@@ -147,12 +143,10 @@ class TestMultipleServerMount:
 
         # Call tools from both mounted servers
         result1 = await main_app._mcp_call_tool("weather_get_forecast", {})
-        assert isinstance(result1[0], TextContent)
-        assert result1[0].text == "Weather forecast"
+        assert result1[0].text == "Weather forecast"  # type: ignore[attr-defined]
 
         result2 = await main_app._mcp_call_tool("news_get_headlines", {})
-        assert isinstance(result2[0], TextContent)
-        assert result2[0].text == "News headlines"
+        assert result2[0].text == "News headlines"  # type: ignore[attr-defined]
 
     async def test_mount_same_prefix(self):
         """Test that mounting with the same prefix replaces the previous mount."""
@@ -227,8 +221,7 @@ class TestMultipleServerMount:
 
             # Test calling a tool
             result = await client.call_tool("working_working_tool", {})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "Working tool"
+            assert result[0].text == "Working tool"  # type: ignore[attr-defined]
 
             # Test resources
             resources = await client.list_resources()
@@ -284,8 +277,7 @@ class TestDynamicChanges:
 
         # Call the dynamically added tool
         result = await main_app._mcp_call_tool("sub_dynamic_tool", {})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "Added after mounting"
+        assert result[0].text == "Added after mounting"  # type: ignore[attr-defined]
 
     async def test_removing_tool_after_mounting(self):
         """Test that tools removed from mounted servers are no longer accessible."""
@@ -335,8 +327,7 @@ class TestResourcesAndTemplates:
         # Check that resource can be accessed
         async with Client(main_app) as client:
             result = await client.read_resource("data://data/users")
-            assert isinstance(result[0], TextResourceContents)
-            assert json.loads(result[0].text) == ["user1", "user2"]
+            assert json.loads(result[0].text) == ["user1", "user2"]  # type: ignore[attr-defined]
 
     async def test_mount_with_resource_templates(self):
         """Test mounting a server with resource templates."""
@@ -357,8 +348,7 @@ class TestResourcesAndTemplates:
         # Check template instantiation
         async with Client(main_app) as client:
             result = await client.read_resource("users://api/123/profile")
-            assert isinstance(result[0], TextResourceContents)
-            profile = json.loads(result[0].text)
+            profile = json.loads(result[0].text)  # type: ignore
             assert profile["id"] == "123"
             assert profile["name"] == "User 123"
 
@@ -382,8 +372,7 @@ class TestResourcesAndTemplates:
         # Check access to the resource
         async with Client(main_app) as client:
             result = await client.read_resource("data://data/config")
-            assert isinstance(result[0], TextResourceContents)
-            config = json.loads(result[0].text)
+            config = json.loads(result[0].text)  # type: ignore[attr-defined]
             assert config["version"] == "1.0"
 
 
@@ -461,8 +450,7 @@ class TestProxyServer:
 
         # Call the tool
         result = await main_app._mcp_call_tool("proxy_get_data", {"query": "test"})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "Data for test"
+        assert result[0].text == "Data for test"  # type: ignore[attr-defined]
 
     async def test_dynamically_adding_to_proxied_server(self):
         """Test that changes to the original server are reflected in the mounted proxy."""
@@ -489,8 +477,7 @@ class TestProxyServer:
 
         # Call the tool
         result = await main_app._mcp_call_tool("proxy_dynamic_data", {})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "Dynamic data"
+        assert result[0].text == "Dynamic data"  # type: ignore[attr-defined]
 
     async def test_proxy_server_with_resources(self):
         """Test mounting a proxy server with resources."""
@@ -512,8 +499,7 @@ class TestProxyServer:
 
         # Resource should be accessible through main app
         result = await main_app._mcp_read_resource("config://proxy/settings")
-        assert isinstance(result[0], ReadResourceContents)
-        config = json.loads(result[0].content)
+        config = json.loads(result[0].content)  # type: ignore[attr-defined]
         assert config["api_key"] == "12345"
 
     async def test_proxy_server_with_prompts(self):

tests/server/test_proxy.py

@@ -1,8 +1,8 @@
 import json
 from typing import Any
 
-import mcp.types
 import pytest
+from anyio import create_task_group
 from dirty_equals import Contains
 from mcp import McpError
 
@@ -89,16 +89,14 @@ async def test_as_proxy_with_server(fastmcp_server):
     """FastMCP.as_proxy should accept a FastMCP instance."""
     proxy = FastMCP.as_proxy(fastmcp_server)
     result = await proxy._mcp_call_tool("greet", {"name": "Test"})
-    assert isinstance(result[0], mcp.types.TextContent)
-    assert result[0].text == "Hello, Test!"
+    assert result[0].text == "Hello, Test!"  # type: ignore[attr-defined]
 
 
 async def test_as_proxy_with_transport(fastmcp_server):
     """FastMCP.as_proxy should accept a ClientTransport."""
     proxy = FastMCP.as_proxy(FastMCPTransport(fastmcp_server))
     result = await proxy._mcp_call_tool("greet", {"name": "Test"})
-    assert isinstance(result[0], mcp.types.TextContent)
-    assert result[0].text == "Hello, Test!"
+    assert result[0].text == "Hello, Test!"  # type: ignore[attr-defined]
 
 
 def test_as_proxy_with_url():
@@ -137,9 +135,7 @@ class TestTools:
     async def test_call_tool_calls_tool(self, proxy_server):
         async with Client(proxy_server) as client:
             proxy_result = await client.call_tool("add", {"a": 1, "b": 2})
-
-        assert isinstance(proxy_result[0], mcp.types.TextContent)
-        assert proxy_result[0].text == "3"
+        assert proxy_result[0].text == "3"  # type: ignore[attr-defined]
 
     async def test_error_tool_raises_error(self, proxy_server):
         with pytest.raises(ToolError, match=""):
@@ -163,8 +159,7 @@ class TestResources:
     async def test_read_resource(self, proxy_server: FastMCPProxy):
         async with Client(proxy_server) as client:
             result = await client.read_resource("resource://wave")
-        assert isinstance(result[0], mcp.types.TextResourceContents)
-        assert result[0].text == "👋"
+        assert result[0].text == "👋"  # type: ignore[attr-defined]
 
     async def test_read_resource_same_as_original(self, fastmcp_server, proxy_server):
         async with Client(fastmcp_server) as client:
@@ -176,8 +171,7 @@ class TestResources:
     async def test_read_json_resource(self, proxy_server: FastMCPProxy):
         async with Client(proxy_server) as client:
             result = await client.read_resource("data://users")
-        assert isinstance(result[0], mcp.types.TextResourceContents)
-        assert json.loads(result[0].text) == USERS
+        assert json.loads(result[0].text) == USERS  # type: ignore[attr-defined]
 
     async def test_read_resource_returns_none_if_not_found(self, proxy_server):
         with pytest.raises(McpError, match="Unknown resource: resource://nonexistent"):
@@ -201,8 +195,7 @@ class TestResourceTemplates:
     async def test_read_resource_template(self, proxy_server: FastMCPProxy, id: int):
         async with Client(proxy_server) as client:
             result = await client.read_resource(f"data://user/{id}")
-        assert isinstance(result[0], mcp.types.TextResourceContents)
-        assert json.loads(result[0].text) == USERS[id - 1]
+        assert json.loads(result[0].text) == USERS[id - 1]  # type: ignore[attr-defined]
 
     async def test_read_resource_template_same_as_original(
         self, fastmcp_server, proxy_server
@@ -238,7 +231,28 @@ class TestPrompts:
     async def test_render_prompt_calls_prompt(self, proxy_server):
         async with Client(proxy_server) as client:
             result = await client.get_prompt("welcome", {"name": "Alice"})
-        assert isinstance(result.messages[0], mcp.types.PromptMessage)
         assert result.messages[0].role == "user"
-        assert isinstance(result.messages[0].content, mcp.types.TextContent)
-        assert result.messages[0].content.text == "Welcome to FastMCP, Alice!"
+        assert result.messages[0].content.text == "Welcome to FastMCP, Alice!"  # type: ignore[attr-defined]
+
+
+async def test_proxy_handles_multiple_concurrent_tasks_correctly(
+    proxy_server: FastMCPProxy,
+):
+    results = {}
+
+    async def get_and_store(name, coro):
+        results[name] = await coro()
+
+    async with create_task_group() as tg:
+        tg.start_soon(get_and_store, "prompts", proxy_server.get_prompts)
+        tg.start_soon(get_and_store, "resources", proxy_server.get_resources)
+        tg.start_soon(get_and_store, "tools", proxy_server.get_tools)
+
+    assert list(results) == Contains("resources", "prompts", "tools")
+    assert list(results["prompts"]) == Contains("welcome")
+    assert [r.name for r in results["resources"].values()] == Contains(
+        "data://users", "resource://wave"
+    )
+    assert list(results["tools"]) == Contains(
+        "greet", "add", "error_tool", "tool_without_description"
+    )

tests/server/test_server.py

@@ -2,10 +2,6 @@ from typing import Annotated
 
 import pytest
 from mcp import McpError
-from mcp.types import (
-    TextContent,
-    TextResourceContents,
-)
 from pydantic import Field
 
 from fastmcp import Client, FastMCP
@@ -16,6 +12,7 @@ from fastmcp.server.server import (
     has_resource_prefix,
     remove_resource_prefix,
 )
+from fastmcp.tools.tool import Tool
 
 
 class TestCreateServer:
@@ -48,8 +45,7 @@ class TestCreateServer:
             result = await client.call_tool("hello_world", {})
             assert len(result) == 1
             content = result[0]
-            assert isinstance(content, TextContent)
-            assert "¡Hola, 世界! 👋" == content.text
+            assert content.text == "¡Hola, 世界! 👋"  # type: ignore[attr-defined]
 
 
 class TestTools:
@@ -98,6 +94,24 @@ class TestTools:
         with pytest.raises(NotFoundError, match="Unknown tool: adder"):
             await mcp._mcp_call_tool("adder", {"a": 1, "b": 2})
 
+    async def test_add_tool_at_init(self):
+        def f(x: int) -> int:
+            return x + 1
+
+        def g(x: int) -> int:
+            """add two to a number"""
+            return x + 2
+
+        g_tool = Tool.from_function(g, name="g-tool")
+
+        mcp = FastMCP(tools=[f, g_tool])
+
+        tools = await mcp.get_tools()
+        assert len(tools) == 2
+        assert tools["f"].name == "f"
+        assert tools["g-tool"].name == "g-tool"
+        assert tools["g-tool"].description == "add two to a number"
+
 
 class TestToolDecorator:
     async def test_no_tools_before_decorator(self):
@@ -114,8 +128,7 @@ class TestToolDecorator:
             return x + y
 
         result = await mcp._mcp_call_tool("add", {"x": 1, "y": 2})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "3"
+        assert result[0].text == "3"  # type: ignore[attr-defined]
 
     async def test_tool_decorator_incorrect_usage(self):
         mcp = FastMCP()
@@ -134,8 +147,7 @@ class TestToolDecorator:
             return x + y
 
         result = await mcp._mcp_call_tool("custom-add", {"x": 1, "y": 2})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "3"
+        assert result[0].text == "3"  # type: ignore[attr-defined]
 
     async def test_tool_decorator_with_description(self):
         mcp = FastMCP()
@@ -163,8 +175,7 @@ class TestToolDecorator:
         obj = MyClass(10)
         mcp.add_tool(obj.add)
         result = await mcp._mcp_call_tool("add", {"y": 2})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "12"
+        assert result[0].text == "12"  # type: ignore[attr-defined]
 
     async def test_tool_decorator_classmethod(self):
         mcp = FastMCP()
@@ -178,8 +189,7 @@ class TestToolDecorator:
 
         mcp.add_tool(MyClass.add)
         result = await mcp._mcp_call_tool("add", {"y": 2})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "12"
+        assert result[0].text == "12"  # type: ignore[attr-defined]
 
     async def test_tool_decorator_staticmethod(self):
         mcp = FastMCP()
@@ -191,8 +201,7 @@ class TestToolDecorator:
                 return x + y
 
         result = await mcp._mcp_call_tool("add", {"x": 1, "y": 2})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "3"
+        assert result[0].text == "3"  # type: ignore[attr-defined]
 
     async def test_tool_decorator_async_function(self):
         mcp = FastMCP()
@@ -202,8 +211,7 @@ class TestToolDecorator:
             return x + y
 
         result = await mcp._mcp_call_tool("add", {"x": 1, "y": 2})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "3"
+        assert result[0].text == "3"  # type: ignore[attr-defined]
 
     async def test_tool_decorator_classmethod_async_function(self):
         mcp = FastMCP()
@@ -217,8 +225,7 @@ class TestToolDecorator:
 
         mcp.add_tool(MyClass.add)
         result = await mcp._mcp_call_tool("add", {"y": 2})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "12"
+        assert result[0].text == "12"  # type: ignore[attr-defined]
 
     async def test_tool_decorator_staticmethod_async_function(self):
         mcp = FastMCP()
@@ -230,8 +237,7 @@ class TestToolDecorator:
 
         mcp.add_tool(MyClass.add)
         result = await mcp._mcp_call_tool("add", {"x": 1, "y": 2})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "3"
+        assert result[0].text == "3"  # type: ignore[attr-defined]
 
     async def test_tool_decorator_with_tags(self):
         """Test that the tool decorator properly sets tags."""
@@ -262,8 +268,7 @@ class TestToolDecorator:
 
         # Call the tool by its custom name
         result = await mcp._mcp_call_tool("custom_multiply", {"a": 5, "b": 3})
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "15"
+        assert result[0].text == "15"  # type: ignore[attr-defined]
 
         # Original name should not be registered
         assert "multiply" not in tools
@@ -316,8 +321,7 @@ class TestResourceDecorator:
 
         async with Client(mcp) as client:
             result = await client.read_resource("resource://data")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Hello, world!"
+            assert result[0].text == "Hello, world!"  # type: ignore[attr-defined]
 
     async def test_resource_decorator_incorrect_usage(self):
         mcp = FastMCP()
@@ -344,8 +348,7 @@ class TestResourceDecorator:
 
         async with Client(mcp) as client:
             result = await client.read_resource("resource://data")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Hello, world!"
+            assert result[0].text == "Hello, world!"  # type: ignore[attr-defined]
 
     async def test_resource_decorator_with_description(self):
         mcp = FastMCP()
@@ -389,8 +392,7 @@ class TestResourceDecorator:
 
         async with Client(mcp) as client:
             result = await client.read_resource("resource://data")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "My prefix: Hello, world!"
+            assert result[0].text == "My prefix: Hello, world!"  # type: ignore[attr-defined]
 
     async def test_resource_decorator_classmethod(self):
         mcp = FastMCP()
@@ -408,8 +410,7 @@ class TestResourceDecorator:
 
         async with Client(mcp) as client:
             result = await client.read_resource("resource://data")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Class prefix: Hello, world!"
+            assert result[0].text == "Class prefix: Hello, world!"  # type: ignore[attr-defined]
 
     async def test_resource_decorator_staticmethod(self):
         mcp = FastMCP()
@@ -422,8 +423,7 @@ class TestResourceDecorator:
 
         async with Client(mcp) as client:
             result = await client.read_resource("resource://data")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Static Hello, world!"
+            assert result[0].text == "Static Hello, world!"  # type: ignore[attr-defined]
 
     async def test_resource_decorator_async_function(self):
         mcp = FastMCP()
@@ -434,8 +434,7 @@ class TestResourceDecorator:
 
         async with Client(mcp) as client:
             result = await client.read_resource("resource://data")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Async Hello, world!"
+            assert result[0].text == "Async Hello, world!"  # type: ignore[attr-defined]
 
 
 class TestTemplateDecorator:
@@ -454,8 +453,7 @@ class TestTemplateDecorator:
 
         async with Client(mcp) as client:
             result = await client.read_resource("resource://test/data")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Data for test"
+            assert result[0].text == "Data for test"  # type: ignore[attr-defined]
 
     async def test_template_decorator_incorrect_usage(self):
         mcp = FastMCP()
@@ -482,8 +480,7 @@ class TestTemplateDecorator:
 
         async with Client(mcp) as client:
             result = await client.read_resource("resource://test/data")
-        assert isinstance(result[0], TextResourceContents)
-        assert result[0].text == "Data for test"
+        assert result[0].text == "Data for test"  # type: ignore[attr-defined]
 
     async def test_template_decorator_with_description(self):
         mcp = FastMCP()
@@ -514,8 +511,7 @@ class TestTemplateDecorator:
 
         async with Client(mcp) as client:
             result = await client.read_resource("resource://test/data")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "My prefix: Data for test"
+            assert result[0].text == "My prefix: Data for test"  # type: ignore[attr-defined]
 
     async def test_template_decorator_classmethod(self):
         mcp = FastMCP()
@@ -535,8 +531,7 @@ class TestTemplateDecorator:
 
         async with Client(mcp) as client:
             result = await client.read_resource("resource://test/data")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Class prefix: Data for test"
+            assert result[0].text == "Class prefix: Data for test"  # type: ignore[attr-defined]
 
     async def test_template_decorator_staticmethod(self):
         mcp = FastMCP()
@@ -549,8 +544,7 @@ class TestTemplateDecorator:
 
         async with Client(mcp) as client:
             result = await client.read_resource("resource://test/data")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Static Data for test"
+            assert result[0].text == "Static Data for test"  # type: ignore[attr-defined]
 
     async def test_template_decorator_async_function(self):
         mcp = FastMCP()
@@ -561,8 +555,7 @@ class TestTemplateDecorator:
 
         async with Client(mcp) as client:
             result = await client.read_resource("resource://test/data")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Async Data for test"
+            assert result[0].text == "Async Data for test"  # type: ignore[attr-defined]
 
     async def test_template_decorator_with_tags(self):
         """Test that the template decorator properly sets tags."""
@@ -603,8 +596,7 @@ class TestPromptDecorator:
         assert prompt.name == "fn"
         # Don't compare functions directly since validate_call wraps them
         content = await prompt.render()
-        assert isinstance(content[0].content, TextContent)
-        assert content[0].content.text == "Hello, world!"
+        assert content[0].content.text == "Hello, world!"  # type: ignore[attr-defined]
 
     async def test_prompt_decorator_incorrect_usage(self):
         mcp = FastMCP()
@@ -629,8 +621,7 @@ class TestPromptDecorator:
         prompt = prompts_dict["custom_name"]
         assert prompt.name == "custom_name"
         content = await prompt.render()
-        assert isinstance(content[0].content, TextContent)
-        assert content[0].content.text == "Hello, world!"
+        assert content[0].content.text == "Hello, world!"  # type: ignore[attr-defined]
 
     async def test_prompt_decorator_with_description(self):
         mcp = FastMCP()
@@ -644,8 +635,7 @@ class TestPromptDecorator:
         prompt = prompts_dict["fn"]
         assert prompt.description == "A custom description"
         content = await prompt.render()
-        assert isinstance(content[0].content, TextContent)
-        assert content[0].content.text == "Hello, world!"
+        assert content[0].content.text == "Hello, world!"  # type: ignore[attr-defined]
 
     async def test_prompt_decorator_with_parameters(self):
         mcp = FastMCP()
@@ -668,16 +658,14 @@ class TestPromptDecorator:
             result = await client.get_prompt("test_prompt", {"name": "World"})
             assert len(result.messages) == 1
             message = result.messages[0]
-            assert isinstance(message.content, TextContent)
-            assert message.content.text == "Hello, World!"
+            assert message.content.text == "Hello, World!"  # type: ignore[attr-defined]
 
             result = await client.get_prompt(
                 "test_prompt", {"name": "World", "greeting": "Hi"}
             )
             assert len(result.messages) == 1
             message = result.messages[0]
-            assert isinstance(message.content, TextContent)
-            assert message.content.text == "Hi, World!"
+            assert message.content.text == "Hi, World!"  # type: ignore[attr-defined]
 
     async def test_prompt_decorator_instance_method(self):
         mcp = FastMCP()
@@ -696,8 +684,7 @@ class TestPromptDecorator:
             result = await client.get_prompt("test_prompt")
             assert len(result.messages) == 1
             message = result.messages[0]
-            assert isinstance(message.content, TextContent)
-            assert message.content.text == "My prefix: Hello, world!"
+            assert message.content.text == "My prefix: Hello, world!"  # type: ignore[attr-defined]
 
     async def test_prompt_decorator_classmethod(self):
         mcp = FastMCP()
@@ -715,8 +702,7 @@ class TestPromptDecorator:
             result = await client.get_prompt("test_prompt")
             assert len(result.messages) == 1
             message = result.messages[0]
-            assert isinstance(message.content, TextContent)
-            assert message.content.text == "Class prefix: Hello, world!"
+            assert message.content.text == "Class prefix: Hello, world!"  # type: ignore[attr-defined]
 
     async def test_prompt_decorator_staticmethod(self):
         mcp = FastMCP()
@@ -731,8 +717,7 @@ class TestPromptDecorator:
             result = await client.get_prompt("test_prompt")
             assert len(result.messages) == 1
             message = result.messages[0]
-            assert isinstance(message.content, TextContent)
-            assert message.content.text == "Static Hello, world!"
+            assert message.content.text == "Static Hello, world!"  # type: ignore[attr-defined]
 
     async def test_prompt_decorator_async_function(self):
         mcp = FastMCP()
@@ -745,8 +730,7 @@ class TestPromptDecorator:
             result = await client.get_prompt("test_prompt")
             assert len(result.messages) == 1
             message = result.messages[0]
-            assert isinstance(message.content, TextContent)
-            assert message.content.text == "Async Hello, world!"
+            assert message.content.text == "Async Hello, world!"  # type: ignore[attr-defined]
 
     async def test_prompt_decorator_with_tags(self):
         """Test that the prompt decorator properly sets tags."""
@@ -943,20 +927,17 @@ class TestResourcePrefixMounting:
         async with Client(main_server) as client:
             # Regular resource
             result = await client.read_resource("resource://prefix/test-resource")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Resource content"
+            assert result[0].text == "Resource content"  # type: ignore[attr-defined]
 
             # Absolute path resource
             result = await client.read_resource("resource://prefix//absolute/path")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Absolute resource content"
+            assert result[0].text == "Absolute resource content"  # type: ignore[attr-defined]
 
             # Template resource
             result = await client.read_resource(
                 "resource://prefix/param-value/template"
             )
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Template resource with param-value"
+            assert result[0].text == "Template resource with param-value"  # type: ignore[attr-defined]
 
     @pytest.mark.parametrize(
         "uri,prefix,expected_match,expected_strip",
@@ -1032,15 +1013,12 @@ class TestResourcePrefixMounting:
         # Verify we can access the resources
         async with Client(target_server) as client:
             result = await client.read_resource("resource://imported/test-resource")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Resource content"
+            assert result[0].text == "Resource content"  # type: ignore[attr-defined]
 
             result = await client.read_resource("resource://imported//absolute/path")
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Absolute resource content"
+            assert result[0].text == "Absolute resource content"  # type: ignore[attr-defined]
 
             result = await client.read_resource(
                 "resource://imported/param-value/template"
             )
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Template resource with param-value"
+            assert result[0].text == "Template resource with param-value"  # type: ignore[attr-defined]

tests/server/test_server_interactions.py

@@ -10,7 +10,6 @@ import pydantic_core
 import pytest
 from mcp import McpError
 from mcp.types import (
-    BlobResourceContents,
     ImageContent,
     TextContent,
     TextResourceContents,
@@ -77,14 +76,12 @@ class TestTools:
     async def test_call_tool(self, tool_server: FastMCP):
         async with Client(tool_server) as client:
             result = await client.call_tool("add", {"x": 1, "y": 2})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "3"
+            assert result[0].text == "3"  # type: ignore[attr-defined]
 
     async def test_call_tool_as_client(self, tool_server: FastMCP):
         async with Client(tool_server) as client:
             result = await client.call_tool("add", {"x": 1, "y": 2})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "3"
+            assert result[0].text == "3"  # type: ignore[attr-defined]
 
     async def test_call_tool_error(self, tool_server: FastMCP):
         async with Client(tool_server) as client:
@@ -113,8 +110,7 @@ class TestTools:
     async def test_tool_returns_list(self, tool_server: FastMCP):
         async with Client(tool_server) as client:
             result = await client.call_tool("list_tool", {})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == '[\n  "x",\n  2\n]'
+            assert result[0].text == '[\n  "x",\n  2\n]'  # type: ignore[attr-defined]
 
 
 class TestToolReturnTypes:
@@ -127,8 +123,7 @@ class TestToolReturnTypes:
 
         async with Client(mcp) as client:
             result = await client.call_tool("string_tool", {})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "Hello, world!"
+            assert result[0].text == "Hello, world!"  # type: ignore[attr-defined]
 
     async def test_bytes(self, tmp_path: Path):
         mcp = FastMCP()
@@ -139,8 +134,7 @@ class TestToolReturnTypes:
 
         async with Client(mcp) as client:
             result = await client.call_tool("bytes_tool", {})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == '"Hello, world!"'
+            assert result[0].text == '"Hello, world!"'  # type: ignore[attr-defined]
 
     async def test_uuid(self):
         mcp = FastMCP()
@@ -153,8 +147,7 @@ class TestToolReturnTypes:
 
         async with Client(mcp) as client:
             result = await client.call_tool("uuid_tool", {})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == pydantic_core.to_json(test_uuid).decode()
+            assert result[0].text == pydantic_core.to_json(test_uuid).decode()  # type: ignore[attr-defined]
 
     async def test_path(self):
         mcp = FastMCP()
@@ -167,8 +160,7 @@ class TestToolReturnTypes:
 
         async with Client(mcp) as client:
             result = await client.call_tool("path_tool", {})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == pydantic_core.to_json(test_path).decode()
+            assert result[0].text == pydantic_core.to_json(test_path).decode()  # type: ignore[attr-defined]
 
     async def test_datetime(self):
         mcp = FastMCP()
@@ -181,8 +173,7 @@ class TestToolReturnTypes:
 
         async with Client(mcp) as client:
             result = await client.call_tool("datetime_tool", {})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == pydantic_core.to_json(dt).decode()
+            assert result[0].text == pydantic_core.to_json(dt).decode()  # type: ignore[attr-defined]
 
     async def test_image(self, tmp_path: Path):
         mcp = FastMCP()
@@ -337,8 +328,7 @@ class TestToolParameters:
         async with Client(mcp) as client:
             # String with integer value should be coerced to int
             result = await client.call_tool("add_one", {"x": "42"})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "43"
+            assert result[0].text == "43"  # type: ignore[attr-defined]
 
     async def test_tool_bool_coercion(self):
         """Test string-to-bool type coercion."""
@@ -351,12 +341,10 @@ class TestToolParameters:
         async with Client(mcp) as client:
             # String with boolean value should be coerced to bool
             result = await client.call_tool("toggle", {"flag": "true"})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "false"
+            assert result[0].text == "false"  # type: ignore[attr-defined]
 
             result = await client.call_tool("toggle", {"flag": "false"})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "true"
+            assert result[0].text == "true"  # type: ignore[attr-defined]
 
     async def test_annotated_field_validation(self):
         mcp = FastMCP()
@@ -411,8 +399,7 @@ class TestToolParameters:
 
         async with Client(mcp) as client:
             result = await client.call_tool("analyze", {"x": "a"})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "a"
+            assert result[0].text == "a"  # type: ignore[attr-defined]
 
     async def test_enum_type_validation_error(self):
         mcp = FastMCP()
@@ -444,8 +431,7 @@ class TestToolParameters:
 
         async with Client(mcp) as client:
             result = await client.call_tool("analyze", {"x": "red"})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "red"
+            assert result[0].text == "red"  # type: ignore[attr-defined]
 
     async def test_union_type_validation(self):
         mcp = FastMCP()
@@ -456,12 +442,10 @@ class TestToolParameters:
 
         async with Client(mcp) as client:
             result = await client.call_tool("analyze", {"x": 1})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "1"
+            assert result[0].text == "1"  # type: ignore[attr-defined]
 
             result = await client.call_tool("analyze", {"x": 1.0})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "1.0"
+            assert result[0].text == "1.0"  # type: ignore[attr-defined]
 
             with pytest.raises(ToolError, match="Error calling tool 'analyze'"):
                 await client.call_tool("analyze", {"x": "not a number"})
@@ -479,8 +463,7 @@ class TestToolParameters:
 
         async with Client(mcp) as client:
             result = await client.call_tool("send_path", {"path": str(test_path)})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == str(test_path)
+            assert result[0].text == str(test_path)  # type: ignore[attr-defined]
 
     async def test_path_type_error(self):
         mcp = FastMCP()
@@ -505,8 +488,7 @@ class TestToolParameters:
 
         async with Client(mcp) as client:
             result = await client.call_tool("send_uuid", {"x": test_uuid})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == str(test_uuid)
+            assert result[0].text == str(test_uuid)  # type: ignore[attr-defined]
 
     async def test_uuid_type_error(self):
         mcp = FastMCP()
@@ -530,8 +512,7 @@ class TestToolParameters:
 
         async with Client(mcp) as client:
             result = await client.call_tool("send_datetime", {"x": dt})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == dt.isoformat()
+            assert result[0].text == dt.isoformat()  # type: ignore[attr-defined]
 
     async def test_datetime_type_parse_string(self):
         mcp = FastMCP()
@@ -544,8 +525,7 @@ class TestToolParameters:
             result = await client.call_tool(
                 "send_datetime", {"x": "2021-01-01T00:00:00"}
             )
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "2021-01-01T00:00:00"
+            assert result[0].text == "2021-01-01T00:00:00"  # type: ignore[attr-defined]
 
     async def test_datetime_type_error(self):
         mcp = FastMCP()
@@ -567,8 +547,7 @@ class TestToolParameters:
 
         async with Client(mcp) as client:
             result = await client.call_tool("send_date", {"x": datetime.date.today()})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == datetime.date.today().isoformat()
+            assert result[0].text == datetime.date.today().isoformat()  # type: ignore[attr-defined]
 
     async def test_date_type_parse_string(self):
         mcp = FastMCP()
@@ -579,8 +558,7 @@ class TestToolParameters:
 
         async with Client(mcp) as client:
             result = await client.call_tool("send_date", {"x": "2021-01-01"})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "2021-01-01"
+            assert result[0].text == "2021-01-01"  # type: ignore[attr-defined]
 
     async def test_timedelta_type(self):
         mcp = FastMCP()
@@ -593,8 +571,7 @@ class TestToolParameters:
             result = await client.call_tool(
                 "send_timedelta", {"x": datetime.timedelta(days=1)}
             )
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "1 day, 0:00:00"
+            assert result[0].text == "1 day, 0:00:00"  # type: ignore[attr-defined]
 
     async def test_timedelta_type_parse_int(self):
         mcp = FastMCP()
@@ -605,8 +582,7 @@ class TestToolParameters:
 
         async with Client(mcp) as client:
             result = await client.call_tool("send_timedelta", {"x": 1000})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "0:16:40"
+            assert result[0].text == "0:16:40"  # type: ignore[attr-defined]
 
 
 class TestToolContextInjection:
@@ -639,7 +615,7 @@ class TestToolContextInjection:
             result = await client.call_tool("tool_with_context", {"x": 42})
             assert len(result) == 1
             content = result[0]
-            assert isinstance(content, TextContent)
+            assert content.text == "2"  # type: ignore[attr-defined]
 
     async def test_async_context(self):
         """Test that context works in async functions."""
@@ -654,8 +630,7 @@ class TestToolContextInjection:
             result = await client.call_tool("async_tool", {"x": 42})
             assert len(result) == 1
             content = result[0]
-            assert isinstance(content, TextContent)
-            assert content.text == "Async request 2: 42"
+            assert content.text == "Async request 2: 42"  # type: ignore[attr-defined]
 
     async def test_optional_context(self):
         """Test that context is optional."""
@@ -669,8 +644,7 @@ class TestToolContextInjection:
             result = await client.call_tool("no_context", {"x": 21})
             assert len(result) == 1
             content = result[0]
-            assert isinstance(content, TextContent)
-            assert content.text == "42"
+            assert content.text == "42"  # type: ignore[attr-defined]
 
     async def test_context_resource_access(self):
         """Test that context can access resources."""
@@ -692,8 +666,7 @@ class TestToolContextInjection:
             result = await client.call_tool("tool_with_resource", {})
             assert len(result) == 1
             content = result[0]
-            assert isinstance(content, TextContent)
-            assert "Read resource: resource data" in content.text
+            assert "Read resource: resource data" in content.text  # type: ignore[attr-defined]
 
     async def test_tool_decorator_with_tags(self):
         """Test that the tool decorator properly sets tags."""
@@ -721,8 +694,7 @@ class TestToolContextInjection:
 
         async with Client(mcp) as client:
             result = await client.call_tool("MyTool", {"x": 2})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "4"
+            assert result[0].text == "4"  # type: ignore[attr-defined]
 
 
 class TestResource:
@@ -739,8 +711,7 @@ class TestResource:
 
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("resource://test"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Hello, world!"
+            assert result[0].text == "Hello, world!"  # type: ignore[attr-defined]
 
     async def test_binary_resource(self):
         mcp = FastMCP()
@@ -758,8 +729,7 @@ class TestResource:
 
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("resource://binary"))
-            assert isinstance(result[0], BlobResourceContents)
-            assert result[0].blob == base64.b64encode(b"Binary data").decode()
+            assert result[0].blob == base64.b64encode(b"Binary data").decode()  # type: ignore[attr-defined]
 
     async def test_file_resource_text(self, tmp_path: Path):
         mcp = FastMCP()
@@ -775,8 +745,7 @@ class TestResource:
 
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("file://test.txt"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Hello from file!"
+            assert result[0].text == "Hello from file!"  # type: ignore[attr-defined]
 
     async def test_file_resource_binary(self, tmp_path: Path):
         mcp = FastMCP()
@@ -795,8 +764,7 @@ class TestResource:
 
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("file://test.bin"))
-            assert isinstance(result[0], BlobResourceContents)
-            assert result[0].blob == base64.b64encode(b"Binary file data").decode()
+            assert result[0].blob == base64.b64encode(b"Binary file data").decode()  # type: ignore[attr-defined]
 
 
 class TestResourceContext:
@@ -810,8 +778,7 @@ class TestResourceContext:
 
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("resource://test"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "2"
+            assert result[0].text == "2"  # type: ignore[attr-defined]
 
 
 class TestResourceTemplates:
@@ -860,8 +827,7 @@ class TestResourceTemplates:
 
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("resource://test/data"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Data for test"
+            assert result[0].text == "Data for test"  # type: ignore[attr-defined]
 
     async def test_resource_mismatched_params(self):
         """Test that mismatched parameters raise an error"""
@@ -888,8 +854,7 @@ class TestResourceTemplates:
             result = await client.read_resource(
                 AnyUrl("resource://cursor/fastmcp/data")
             )
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Data for cursor/fastmcp"
+            assert result[0].text == "Data for cursor/fastmcp"  # type: ignore[attr-defined]
 
     async def test_resource_multiple_mismatched_params(self):
         """Test that mismatched parameters raise an error"""
@@ -913,8 +878,7 @@ class TestResourceTemplates:
 
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("resource://static"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Static data"
+            assert result[0].text == "Static data"  # type: ignore[attr-defined]
 
     async def test_template_with_varkwargs(self):
         """Test that a template can have **kwargs."""
@@ -926,8 +890,7 @@ class TestResourceTemplates:
 
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("test://1/2/3"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "6"
+            assert result[0].text == "6"  # type: ignore[attr-defined]
 
     async def test_template_with_default_params(self):
         """Test that a template can have default parameters."""
@@ -946,13 +909,11 @@ class TestResourceTemplates:
         # Call the template and verify it uses the default value
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("math://add/5"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "15"  # 5 + default 10
+            assert result[0].text == "15"  # type: ignore[attr-defined]
 
             # Can also call with explicit params
             result2 = await client.read_resource(AnyUrl("math://add/7"))
-            assert isinstance(result2[0], TextResourceContents)
-            assert result2[0].text == "17"  # 7 + default 10
+            assert result2[0].text == "17"  # type: ignore[attr-defined]
 
     async def test_template_to_resource_conversion(self):
         """Test that a template can be converted to a resource."""
@@ -971,8 +932,7 @@ class TestResourceTemplates:
         # When accessed, should create a concrete resource
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("resource://test/data"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Data for test"
+            assert result[0].text == "Data for test"  # type: ignore[attr-defined]
 
     async def test_stacked_resource_template_decorators(self):
         """Test that resource template decorators can be stacked."""
@@ -1011,15 +971,15 @@ class TestResourceTemplates:
             email_result = await client.read_resource(
                 AnyUrl("users://email/user@example.com")
             )
-            assert isinstance(email_result[0], TextResourceContents)
-            email_data = json.loads(email_result[0].text)
+            assert email_result[0].text  # type: ignore[attr-defined]
+            email_data = json.loads(email_result[0].text)  # type: ignore[attr-defined]
             assert email_data["lookup"] == "email"
             assert email_data["email"] == "user@example.com"
 
             # Test lookup by name
             name_result = await client.read_resource(AnyUrl("users://name/John"))
-            assert isinstance(name_result[0], TextResourceContents)
-            name_data = json.loads(name_result[0].text)
+            assert name_result[0].text  # type: ignore[attr-defined]
+            name_data = json.loads(name_result[0].text)  # type: ignore[attr-defined]
             assert name_data["lookup"] == "name"
             assert name_data["name"] == "John"
             assert name_data["email"] == "dummy@example.com"
@@ -1044,8 +1004,7 @@ class TestResourceTemplates:
 
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("resource://test/data"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Template resource: test/data"
+            assert result[0].text == "Template resource: test/data"  # type: ignore[attr-defined]
 
     async def test_templates_match_in_order_of_definition(self):
         """
@@ -1065,12 +1024,10 @@ class TestResourceTemplates:
 
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("resource://a/b/c"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Template resource 1: a/b/c"
+            assert result[0].text == "Template resource 1: a/b/c"  # type: ignore[attr-defined]
 
             result = await client.read_resource(AnyUrl("resource://a/b"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Template resource 1: a/b"
+            assert result[0].text == "Template resource 1: a/b"  # type: ignore[attr-defined]
 
     async def test_templates_shadow_each_other_reorder(self):
         """
@@ -1089,12 +1046,10 @@ class TestResourceTemplates:
 
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("resource://a/b/c"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Template resource 2: a/b/c"
+            assert result[0].text == "Template resource 2: a/b/c"  # type: ignore[attr-defined]
 
             result = await client.read_resource(AnyUrl("resource://a/b"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text == "Template resource 1: a/b"
+            assert result[0].text == "Template resource 1: a/b"  # type: ignore[attr-defined]
 
 
 class TestResourceTemplateContext:
@@ -1108,8 +1063,7 @@ class TestResourceTemplateContext:
 
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("resource://test"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text.startswith("Resource template: test 2")
+            assert result[0].text.startswith("Resource template: test 2")  # type: ignore[attr-defined]
 
     async def test_resource_template_context_with_callable_object(self):
         mcp = FastMCP()
@@ -1122,8 +1076,7 @@ class TestResourceTemplateContext:
 
         async with Client(mcp) as client:
             result = await client.read_resource(AnyUrl("resource://test"))
-            assert isinstance(result[0], TextResourceContents)
-            assert result[0].text.startswith("Resource template: test 2")
+            assert result[0].text.startswith("Resource template: test 2")  # type: ignore[attr-defined]
 
 
 class TestPrompts:
@@ -1143,8 +1096,7 @@ class TestPrompts:
         assert prompt.name == "fn"
         # Don't compare functions directly since validate_call wraps them
         content = await prompt.render()
-        assert isinstance(content[0].content, TextContent)
-        assert content[0].content.text == "Hello, world!"
+        assert content[0].content.text == "Hello, world!"  # type: ignore[attr-defined]
 
     async def test_prompt_decorator_with_name(self):
         """Test prompt decorator with custom name."""
@@ -1159,8 +1111,7 @@ class TestPrompts:
         prompt = prompts_dict["custom_name"]
         assert prompt.name == "custom_name"
         content = await prompt.render()
-        assert isinstance(content[0].content, TextContent)
-        assert content[0].content.text == "Hello, world!"
+        assert content[0].content.text == "Hello, world!"  # type: ignore[attr-defined]
 
     async def test_prompt_decorator_with_description(self):
         """Test prompt decorator with custom description."""
@@ -1175,8 +1126,7 @@ class TestPrompts:
         prompt = prompts_dict["fn"]
         assert prompt.description == "A custom description"
         content = await prompt.render()
-        assert isinstance(content[0].content, TextContent)
-        assert content[0].content.text == "Hello, world!"
+        assert content[0].content.text == "Hello, world!"  # type: ignore[attr-defined]
 
     def test_prompt_decorator_error(self):
         """Test error when decorator is used incorrectly."""
@@ -1224,8 +1174,7 @@ class TestPrompts:
             message = result.messages[0]
             assert message.role == "user"
             content = message.content
-            assert isinstance(content, TextContent)
-            assert content.text == "Hello, World!"
+            assert content.text == "Hello, World!"  # type: ignore[attr-defined]
 
     async def test_get_prompt_with_resource(self):
         """Test getting a prompt that returns resource content."""
@@ -1249,10 +1198,10 @@ class TestPrompts:
             result = await client.get_prompt("fn")
             assert result.messages[0].role == "user"
             content = result.messages[0].content
-            assert isinstance(content, EmbeddedResource)
+            assert isinstance(content, EmbeddedResource)  # type: ignore[attr-defined]
             resource = content.resource
-            assert isinstance(resource, TextResourceContents)
-            assert resource.text == "File contents"
+            assert isinstance(resource, TextResourceContents)  # type: ignore[attr-defined]
+            assert resource.text == "File contents"  # type: ignore[attr-defined]
             assert resource.mimeType == "text/plain"
 
     async def test_get_unknown_prompt(self):
@@ -1342,5 +1291,4 @@ class TestPromptContext:
             assert len(result.messages) == 1
             message = result.messages[0]
             assert message.role == "user"
-            assert isinstance(message.content, TextContent)
-            assert message.content.text == "Hello, World! 2"
+            assert message.content.text == "Hello, World! 2"  # type: ignore[attr-defined]

tests/server/test_tool_annotations.py

@@ -1,6 +1,6 @@
 from typing import Any
 
-from mcp.types import TextContent, ToolAnnotations
+from mcp.types import ToolAnnotations
 
 from fastmcp import Client, FastMCP
 
@@ -212,8 +212,7 @@ async def test_tool_functionality_with_annotations():
             "create_item", {"name": "test_item", "value": 42}
         )
         assert len(result) == 1
-        assert isinstance(result[0], TextContent)
 
         # The result should contain the expected JSON
-        assert '"name": "test_item"' in result[0].text
-        assert '"value": 42' in result[0].text
+        assert '"name": "test_item"' in result[0].text  # type: ignore[attr-defined]
+        assert '"value": 42' in result[0].text  # type: ignore[attr-defined]

tests/test_examples.py

@@ -1,10 +1,5 @@
 """Tests for example servers"""
 
-from mcp.types import (
-    PromptMessage,
-    TextContent,
-    TextResourceContents,
-)
 from pydantic import AnyUrl
 
 from fastmcp import Client
@@ -17,8 +12,7 @@ async def test_simple_echo():
     async with Client(mcp) as client:
         result = await client.call_tool("echo", {"text": "hello"})
         assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "hello"
+        assert result[0].text == "hello"  # type: ignore[attr-defined]
 
 
 async def test_complex_inputs():
@@ -31,8 +25,7 @@ async def test_complex_inputs():
             "name_shrimp", {"tank": tank, "extra_names": ["charlie"]}
         )
         assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == '[\n  "bob",\n  "alice",\n  "charlie"\n]'
+        assert result[0].text == '[\n  "bob",\n  "alice",\n  "charlie"\n]'  # type: ignore[attr-defined]
 
 
 async def test_desktop(monkeypatch):
@@ -43,15 +36,12 @@ async def test_desktop(monkeypatch):
         # Test the add function
         result = await client.call_tool("add", {"a": 1, "b": 2})
         assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "3"
+        assert result[0].text == "3"  # type: ignore[attr-defined]
 
     async with Client(mcp) as client:
         result = await client.read_resource(AnyUrl("greeting://rooter12"))
         assert len(result) == 1
-        assert isinstance(result[0], TextResourceContents)
-        assert isinstance(result[0].text, str)
-        assert result[0].text == "Hello, rooter12!"
+        assert result[0].text == "Hello, rooter12!"  # type: ignore[attr-defined]
 
 
 async def test_echo():
@@ -61,27 +51,19 @@ async def test_echo():
     async with Client(mcp) as client:
         result = await client.call_tool("echo_tool", {"text": "hello"})
         assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "hello"
+        assert result[0].text == "hello"  # type: ignore[attr-defined]
 
     async with Client(mcp) as client:
         result = await client.read_resource(AnyUrl("echo://static"))
         assert len(result) == 1
-        assert isinstance(result[0], TextResourceContents)
-        assert isinstance(result[0].text, str)
-        assert result[0].text == "Echo!"
+        assert result[0].text == "Echo!"  # type: ignore[attr-defined]
 
     async with Client(mcp) as client:
         result = await client.read_resource(AnyUrl("echo://server42"))
         assert len(result) == 1
-        assert isinstance(result[0], TextResourceContents)
-        assert isinstance(result[0].text, str)
-        assert result[0].text == "Echo: server42"
+        assert result[0].text == "Echo: server42"  # type: ignore[attr-defined]
 
     async with Client(mcp) as client:
         result = await client.get_prompt("echo", {"text": "hello"})
         assert len(result.messages) == 1
-        assert isinstance(result.messages[0], PromptMessage)
-        assert isinstance(result.messages[0].content, TextContent)
-        assert isinstance(result.messages[0].content.text, str)
-        assert result.messages[0].content.text == "hello"
+        assert result.messages[0].content.text == "hello"  # type: ignore[attr-defined]

tests/tools/test_tool.py

@@ -1,5 +1,5 @@
 import pytest
-from mcp.types import ImageContent, TextContent
+from mcp.types import ImageContent
 from pydantic import BaseModel
 
 from fastmcp import FastMCP, Image
@@ -209,9 +209,7 @@ class TestLegacyToolJsonParsing:
 
         # Run the tool which will do JSON parsing
         result = await tool.run(json_args)
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "1-a,b,c"
+        assert result[0].text == "1-a,b,c"  # type: ignore[attr-dict]
 
     async def test_str_vs_list_str(self):
         """Test handling of string vs list[str] type annotations."""
@@ -223,23 +221,17 @@ class TestLegacyToolJsonParsing:
 
         # Test regular string input (should remain a string)
         result = await tool.run({"str_or_list": "hello"})
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "hello"
+        assert result[0].text == "hello"  # type: ignore[attr-dict]
 
         # Test JSON string input (should be parsed as a string)
         result = await tool.run({"str_or_list": '"hello"'})
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "hello"
+        assert result[0].text == "hello"  # type: ignore[attr-dict]
 
         # Test JSON list input (should be parsed as a list)
         result = await tool.run({"str_or_list": '["hello", "world"]'})
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
 
         # The exact formatting might vary, so we just check that it contains the key elements
-        text_without_whitespace = result[0].text.replace(" ", "").replace("\n", "")
+        text_without_whitespace = result[0].text.replace(" ", "").replace("\n", "")  # type: ignore[attr-dict]
         assert "hello" in text_without_whitespace
         assert "world" in text_without_whitespace
         assert "[" in text_without_whitespace
@@ -256,9 +248,7 @@ class TestLegacyToolJsonParsing:
         # Invalid JSON should remain a string
         invalid_json = "{'nice to meet you': 'hello', 'goodbye': 5}"
         result = await tool.run({"string": invalid_json})
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == invalid_json
+        assert result[0].text == invalid_json  # type: ignore[attr-dict]
 
     async def test_keep_str_union_as_str(self):
         """Test that string arguments are kept as strings when parsing would create an invalid value"""
@@ -273,9 +263,7 @@ class TestLegacyToolJsonParsing:
         # Invalid JSON for the union type should remain a string
         invalid_json = "{'nice to meet you': 'hello', 'goodbye': 5}"
         result = await tool.run({"string": invalid_json})
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == invalid_json
+        assert result[0].text == invalid_json  # type: ignore[attr-dict]
 
     async def test_complex_type_validation(self):
         """Test that parsed JSON is validated against complex types"""
@@ -292,11 +280,9 @@ class TestLegacyToolJsonParsing:
         # Valid JSON for the model
         valid_json = '{"x": 1, "y": {"1": "hello"}}'
         result = await tool.run({"data": valid_json})
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert '"x": 1' in result[0].text
-        assert '"y": {' in result[0].text
-        assert '"1": "hello"' in result[0].text
+        assert '"x": 1' in result[0].text  # type: ignore[attr-dict]
+        assert '"y": {' in result[0].text  # type: ignore[attr-dict]
+        assert '"1": "hello"' in result[0].text  # type: ignore[attr-dict]
 
         # Invalid JSON for the model (y has string keys, not int keys)
         # Should throw a validation error
@@ -317,8 +303,7 @@ class TestLegacyToolJsonParsing:
             result = await client.call_tool(
                 "process_list", {"items": "[1, 2, 3, 4, 5]"}
             )
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "15"
+            assert result[0].text == "15"  # type: ignore[attr-dict]
 
     async def test_tool_list_coercion_error(self):
         """Test that a list coercion error is raised if the input is not a valid list."""
@@ -348,8 +333,7 @@ class TestLegacyToolJsonParsing:
             result = await client.call_tool(
                 "process_dict", {"data": '{"a": 1, "b": "2", "c": 3}'}
             )
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "6"
+            assert result[0].text == "6"  # type: ignore[attr-dict]
 
     async def test_tool_set_coercion(self):
         """Test JSON string to set type coercion."""
@@ -362,8 +346,7 @@ class TestLegacyToolJsonParsing:
 
         async with Client(mcp) as client:
             result = await client.call_tool("process_set", {"items": "[1, 2, 3, 4, 5]"})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "15"
+            assert result[0].text == "15"  # type: ignore[attr-dict]
 
     async def test_tool_tuple_coercion(self):
         """Test JSON string to tuple type coercion."""
@@ -376,5 +359,4 @@ class TestLegacyToolJsonParsing:
 
         async with Client(mcp) as client:
             result = await client.call_tool("process_tuple", {"items": '["1", "two"]'})
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "4"
+            assert result[0].text == "4"  # type: ignore[attr-dict]

tests/tools/test_tool_manager.py

@@ -5,7 +5,7 @@ from typing import Annotated, Any
 
 import pydantic_core
 import pytest
-from mcp.types import ImageContent, TextContent
+from mcp.types import ImageContent
 from pydantic import BaseModel
 
 from fastmcp import Context, FastMCP, Image
@@ -318,13 +318,8 @@ class TestCallTools:
         manager = ToolManager()
         manager.add_tool_from_fn(add)
         result = await manager.call_tool("add", {"a": 1, "b": 2})
-        assert isinstance(result, list)
-        assert len(result) == 1
-        from mcp.types import TextContent
 
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "3"
-        assert json.loads(result[0].text) == 3
+        assert result[0].text == "3"  # type: ignore[attr-defined]
 
     async def test_call_async_tool(self):
         async def double(n: int) -> int:
@@ -334,12 +329,7 @@ class TestCallTools:
         manager = ToolManager()
         manager.add_tool_from_fn(double)
         result = await manager.call_tool("double", {"n": 5})
-        assert isinstance(result, list)
-        assert len(result) == 1
-
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "10"
-        assert json.loads(result[0].text) == 10
+        assert result[0].text == "10"  # type: ignore[attr-defined]
 
     async def test_call_tool_callable_object(self):
         class Adder:
@@ -352,11 +342,7 @@ class TestCallTools:
         manager = ToolManager()
         manager.add_tool_from_fn(Adder())
         result = await manager.call_tool("Adder", {"x": 1, "y": 2})
-        assert isinstance(result, list)
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "3"
-        assert json.loads(result[0].text) == 3
+        assert result[0].text == "3"  # type: ignore[attr-defined]
 
     async def test_call_tool_callable_object_async(self):
         class Adder:
@@ -369,11 +355,7 @@ class TestCallTools:
         manager = ToolManager()
         manager.add_tool_from_fn(Adder())
         result = await manager.call_tool("Adder", {"x": 1, "y": 2})
-        assert isinstance(result, list)
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "3"
-        assert json.loads(result[0].text) == 3
+        assert result[0].text == "3"  # type: ignore[attr-defined]
 
     async def test_call_tool_with_default_args(self):
         def add(a: int, b: int = 1) -> int:
@@ -383,12 +365,8 @@ class TestCallTools:
         manager = ToolManager()
         manager.add_tool_from_fn(add)
         result = await manager.call_tool("add", {"a": 1})
-        assert isinstance(result, list)
-        assert len(result) == 1
 
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "2"
-        assert json.loads(result[0].text) == 2
+        assert result[0].text == "2"  # type: ignore[attr-defined]
 
     async def test_call_tool_with_missing_args(self):
         def add(a: int, b: int) -> int:
@@ -413,11 +391,7 @@ class TestCallTools:
         manager.add_tool_from_fn(sum_vals)
 
         result = await manager.call_tool("sum_vals", {"vals": [1, 2, 3]})
-        assert isinstance(result, list)
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "6"
-        assert json.loads(result[0].text) == 6
+        assert result[0].text == "6"  # type: ignore[attr-defined]
 
     async def test_call_tool_with_list_int_input_legacy_behavior(self):
         """Legacy behavior -- parse a stringified JSON object"""
@@ -431,11 +405,7 @@ class TestCallTools:
 
         with temporary_settings(tool_attempt_parse_json_args=True):
             result = await manager.call_tool("sum_vals", {"vals": "[1, 2, 3]"})
-            assert isinstance(result, list)
-            assert len(result) == 1
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "6"
-            assert json.loads(result[0].text) == 6
+            assert result[0].text == "6"  # type: ignore[attr-defined]
 
     async def test_call_tool_with_list_str_or_str_input(self):
         def concat_strs(vals: list[str] | str) -> str:
@@ -446,16 +416,10 @@ class TestCallTools:
 
         # Try both with plain python object and with JSON list
         result = await manager.call_tool("concat_strs", {"vals": ["a", "b", "c"]})
-        assert isinstance(result, list)
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "abc"
+        assert result[0].text == "abc"  # type: ignore[attr-defined]
 
         result = await manager.call_tool("concat_strs", {"vals": "a"})
-        assert isinstance(result, list)
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "a"
+        assert result[0].text == "a"  # type: ignore[attr-defined]
 
     async def test_call_tool_with_list_str_or_str_input_legacy_behavior(self):
         """Legacy behavior -- parse a stringified JSON object"""
@@ -468,16 +432,10 @@ class TestCallTools:
 
         with temporary_settings(tool_attempt_parse_json_args=True):
             result = await manager.call_tool("concat_strs", {"vals": '["a", "b", "c"]'})
-            assert isinstance(result, list)
-            assert len(result) == 1
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "abc"
+            assert result[0].text == "abc"  # type: ignore[attr-defined]
 
             result = await manager.call_tool("concat_strs", {"vals": '"a"'})
-            assert isinstance(result, list)
-            assert len(result) == 1
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "a"
+            assert result[0].text == "a"  # type: ignore[attr-defined]
 
     async def test_call_tool_with_complex_model(self):
         class MyShrimpTank(BaseModel):
@@ -507,10 +465,7 @@ class TestCallTools:
                 },
             )
 
-        assert isinstance(result, list)
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == '[\n  "rex",\n  "gertrude"\n]'
+        assert result[0].text == '[\n  "rex",\n  "gertrude"\n]'  # type: ignore[attr-defined]
 
     async def test_call_tool_with_custom_serializer(self):
         """Test that a custom serializer provided to FastMCP is used by tools."""
@@ -530,10 +485,7 @@ class TestCallTools:
         manager.add_tool_from_fn(get_data)
 
         result = await manager.call_tool("get_data", {})
-        assert isinstance(result, list)
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == 'CUSTOM:{"key": "value", "number": 123}'
+        assert result[0].text == 'CUSTOM:{"key": "value", "number": 123}'  # type: ignore[attr-defined]
 
     async def test_call_tool_with_list_result_custom_serializer(self):
         """Test that a custom serializer provided to FastMCP is used by tools that return lists."""
@@ -555,12 +507,9 @@ class TestCallTools:
         manager.add_tool_from_fn(get_data)
 
         result = await manager.call_tool("get_data", {})
-        assert isinstance(result, list)
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
         assert (
-            result[0].text
-            == 'CUSTOM:[{"key": "value", "number": 123}, {"key": "value2", "number": 456}]'
+            result[0].text  # type: ignore[attr-defined]
+            == 'CUSTOM:[{"key": "value", "number": 123}, {"key": "value2", "number": 456}]'  # type: ignore[attr-defined]
         )
 
     async def test_custom_serializer_fallback_on_error(self):
@@ -580,10 +529,7 @@ class TestCallTools:
         manager.add_tool_from_fn(get_data)
 
         result = await manager.call_tool("get_data", {})
-        assert isinstance(result, list)
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == pydantic_core.to_json(uuid_result).decode()
+        assert result[0].text == pydantic_core.to_json(uuid_result).decode()  # type: ignore[attr-defined]
 
 
 class TestToolSchema:
@@ -648,10 +594,7 @@ class TestContextHandling:
 
         with context:
             result = await manager.call_tool("tool_with_context", {"x": 42})
-            assert isinstance(result, list)
-            assert len(result) == 1
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "42"
+            assert result[0].text == "42"  # type: ignore[attr-defined]
 
     async def test_context_injection_async(self):
         """Test that context is properly injected in async tools."""
@@ -668,14 +611,10 @@ class TestContextHandling:
 
         with context:
             result = await manager.call_tool("async_tool", {"x": 42})
-            assert isinstance(result, list)
-            assert len(result) == 1
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "42"
+            assert result[0].text == "42"  # type: ignore[attr-defined]
 
     async def test_context_optional(self):
         """Test that context is optional when calling tools."""
-        from mcp.types import TextContent
 
         def tool_with_context(x: int, ctx: Context | None) -> int:
             return x
@@ -689,10 +628,7 @@ class TestContextHandling:
 
         with context:
             result = await manager.call_tool("tool_with_context", {"x": 42})
-            assert isinstance(result, list)
-            assert len(result) == 1
-            assert isinstance(result[0], TextContent)
-            assert result[0].text == "42"
+            assert result[0].text == "42"  # type: ignore[attr-defined]
 
     def test_parameterized_context_parameter_detection(self):
         """Test that context parameters are properly detected in
@@ -782,7 +718,6 @@ class TestCustomToolNames:
 
     async def test_call_tool_with_custom_name(self):
         """Test calling a tool added with a custom name."""
-        from mcp.types import TextContent
 
         def multiply(a: int, b: int) -> int:
             """Multiply two numbers."""
@@ -793,11 +728,7 @@ class TestCustomToolNames:
 
         # Tool should be callable by its custom name
         result = await manager.call_tool("custom_multiply", {"a": 5, "b": 3})
-        assert isinstance(result, list)
-        assert len(result) == 1
-        assert isinstance(result[0], TextContent)
-        assert result[0].text == "15"
-        assert json.loads(result[0].text) == 15
+        assert result[0].text == "15"  # type: ignore[attr-defined]
 
         # Original name should not be registered
         with pytest.raises(NotFoundError, match="Unknown tool: multiply"):

tests/utilities/test_mcp_config.py

@@ -1,8 +1,6 @@
 import inspect
 from pathlib import Path
 
-from mcp.types import TextContent
-
 from fastmcp.client.client import Client
 from fastmcp.client.transports import (
     SSETransport,
@@ -136,7 +134,5 @@ async def test_multi_client(tmp_path: Path):
 
         result_1 = await client.call_tool("test_1_add", {"a": 1, "b": 2})
         result_2 = await client.call_tool("test_2_add", {"a": 1, "b": 2})
-        assert isinstance(result_1[0], TextContent)
-        assert result_1[0].text == "3"
-        assert isinstance(result_2[0], TextContent)
-        assert result_2[0].text == "3"
+        assert result_1[0].text == "3"  # type: ignore[attr-dict]
+        assert result_2[0].text == "3"  # type: ignore[attr-dict]