fastmcp 2.12.2__py3-none-any.whl → 2.12.4__py3-none-any.whl

fastmcp/server/auth/providers/google.py

@@ -32,6 +32,7 @@ from fastmcp.server.auth.auth import AccessToken
 from fastmcp.server.auth.oauth_proxy import OAuthProxy
 from fastmcp.utilities.auth import parse_scopes
 from fastmcp.utilities.logging import get_logger
+from fastmcp.utilities.storage import KVStorage
 from fastmcp.utilities.types import NotSet, NotSetT
 
 logger = get_logger(__name__)
@@ -217,6 +218,7 @@ class GoogleProvider(OAuthProxy):
         required_scopes: list[str] | NotSetT = NotSet,
         timeout_seconds: int | NotSetT = NotSet,
         allowed_client_redirect_uris: list[str] | NotSetT = NotSet,
+        client_storage: KVStorage | None = None,
     ):
         """Initialize Google OAuth provider.
 
@@ -232,6 +234,8 @@ class GoogleProvider(OAuthProxy):
             timeout_seconds: HTTP request timeout for Google API calls
             allowed_client_redirect_uris: List of allowed redirect URI patterns for MCP clients.
                 If None (default), all URIs are allowed. If empty list, no URIs are allowed.
+            client_storage: Storage implementation for OAuth client registrations.
+                Defaults to file-based storage if not specified.
         """
 
         settings = GoogleProviderSettings.model_validate(
@@ -261,7 +265,6 @@ class GoogleProvider(OAuthProxy):
             )
 
         # Apply defaults
-        redirect_path_final = settings.redirect_path or "/auth/callback"
         timeout_seconds_final = settings.timeout_seconds or 10
         # Google requires at least one scope - openid is the minimal OIDC scope
         required_scopes_final = settings.required_scopes or ["openid"]
@@ -286,9 +289,10 @@ class GoogleProvider(OAuthProxy):
             upstream_client_secret=client_secret_str,
             token_verifier=token_verifier,
             base_url=settings.base_url,
-            redirect_path=redirect_path_final,
+            redirect_path=settings.redirect_path,
             issuer_url=settings.base_url,  # We act as the issuer for client registration
             allowed_client_redirect_uris=allowed_client_redirect_uris_final,
+            client_storage=client_storage,
         )
 
         logger.info(

fastmcp/server/auth/providers/workos.py

@@ -23,6 +23,7 @@ from fastmcp.server.auth.oauth_proxy import OAuthProxy
 from fastmcp.server.auth.providers.jwt import JWTVerifier
 from fastmcp.utilities.auth import parse_scopes
 from fastmcp.utilities.logging import get_logger
+from fastmcp.utilities.storage import KVStorage
 from fastmcp.utilities.types import NotSet, NotSetT
 
 logger = get_logger(__name__)
@@ -169,6 +170,7 @@ class WorkOSProvider(OAuthProxy):
         required_scopes: list[str] | None | NotSetT = NotSet,
         timeout_seconds: int | NotSetT = NotSet,
         allowed_client_redirect_uris: list[str] | NotSetT = NotSet,
+        client_storage: KVStorage | None = None,
     ):
         """Initialize WorkOS OAuth provider.
 
@@ -182,6 +184,8 @@ class WorkOSProvider(OAuthProxy):
             timeout_seconds: HTTP request timeout for WorkOS API calls
             allowed_client_redirect_uris: List of allowed redirect URI patterns for MCP clients.
                 If None (default), all URIs are allowed. If empty list, no URIs are allowed.
+            client_storage: Storage implementation for OAuth client registrations.
+                Defaults to file-based storage if not specified.
         """
 
         settings = WorkOSProviderSettings.model_validate(
@@ -220,7 +224,6 @@ class WorkOSProvider(OAuthProxy):
         if not authkit_domain_str.startswith(("http://", "https://")):
             authkit_domain_str = f"https://{authkit_domain_str}"
         authkit_domain_final = authkit_domain_str.rstrip("/")
-        redirect_path_final = settings.redirect_path or "/auth/callback"
         timeout_seconds_final = settings.timeout_seconds or 10
         scopes_final = settings.required_scopes or []
         allowed_client_redirect_uris_final = settings.allowed_client_redirect_uris
@@ -245,9 +248,10 @@ class WorkOSProvider(OAuthProxy):
             upstream_client_secret=client_secret_str,
             token_verifier=token_verifier,
             base_url=settings.base_url,
-            redirect_path=redirect_path_final,
+            redirect_path=settings.redirect_path,
             issuer_url=settings.base_url,
             allowed_client_redirect_uris=allowed_client_redirect_uris_final,
+            client_storage=client_storage,
         )
 
         logger.info(

fastmcp/server/context.py

@@ -5,7 +5,7 @@ import copy
 import inspect
 import warnings
 import weakref
-from collections.abc import Generator, Mapping
+from collections.abc import Generator, Mapping, Sequence
 from contextlib import contextmanager
 from contextvars import ContextVar, Token
 from dataclasses import dataclass
@@ -17,9 +17,10 @@ from mcp.server.lowlevel.helper_types import ReadResourceContents
 from mcp.server.lowlevel.server import request_ctx
 from mcp.shared.context import RequestContext
 from mcp.types import (
+    AudioContent,
     ClientCapabilities,
-    ContentBlock,
     CreateMessageResult,
+    ImageContent,
     IncludeContext,
     ModelHint,
     ModelPreferences,
@@ -85,18 +86,18 @@ class Context:
 
     ```python
     @server.tool
-    def my_tool(x: int, ctx: Context) -> str:
+    async def my_tool(x: int, ctx: Context) -> str:
         # Log messages to the client
-        ctx.info(f"Processing {x}")
-        ctx.debug("Debug info")
-        ctx.warning("Warning message")
-        ctx.error("Error message")
+        await ctx.info(f"Processing {x}")
+        await ctx.debug("Debug info")
+        await ctx.warning("Warning message")
+        await ctx.error("Error message")
 
         # Report progress
-        ctx.report_progress(50, 100, "Processing")
+        await ctx.report_progress(50, 100, "Processing")
 
         # Access resources
-        data = ctx.read_resource("resource://data")
+        data = await ctx.read_resource("resource://data")
 
         # Get request info
         request_id = ctx.request_id
@@ -359,13 +360,13 @@ class Context:
 
     async def sample(
         self,
-        messages: str | list[str | SamplingMessage],
+        messages: str | Sequence[str | SamplingMessage],
         system_prompt: str | None = None,
         include_context: IncludeContext | None = None,
         temperature: float | None = None,
         max_tokens: int | None = None,
         model_preferences: ModelPreferences | str | list[str] | None = None,
-    ) -> ContentBlock:
+    ) -> TextContent | ImageContent | AudioContent:
         """
         Send a sampling request to the client and await the response.
 
@@ -383,7 +384,7 @@ class Context:
                     content=TextContent(text=messages, type="text"), role="user"
                 )
             ]
-        elif isinstance(messages, list):
+        elif isinstance(messages, Sequence):
             sampling_messages = [
                 SamplingMessage(content=TextContent(text=m, type="text"), role="user")
                 if isinstance(m, str)
@@ -449,7 +450,7 @@ class Context:
         AcceptedElicitation[dict[str, Any]] | DeclinedElicitation | CancelledElicitation
     ): ...
 
-    """When response_type is None, the accepted elicitaiton will contain an
+    """When response_type is None, the accepted elicitation will contain an
     empty dict"""
 
     @overload
@@ -459,7 +460,7 @@ class Context:
         response_type: type[T],
     ) -> AcceptedElicitation[T] | DeclinedElicitation | CancelledElicitation: ...
 
-    """When response_type is not None, the accepted elicitaiton will contain the
+    """When response_type is not None, the accepted elicitation will contain the
     response data"""
 
     @overload
@@ -469,7 +470,7 @@ class Context:
         response_type: list[str],
     ) -> AcceptedElicitation[str] | DeclinedElicitation | CancelledElicitation: ...
 
-    """When response_type is a list of strings, the accepted elicitaiton will
+    """When response_type is a list of strings, the accepted elicitation will
     contain the selected string response"""
 
     async def elicit(
@@ -573,7 +574,7 @@ class Context:
             warnings.warn(
                 "Context.get_http_request() is deprecated and will be removed in a future version. "
                 "Use get_http_request() from fastmcp.server.dependencies instead. "
-                "See https://gofastmcp.com/patterns/http-requests for more details.",
+                "See https://gofastmcp.com/servers/context#http-requests for more details.",
                 DeprecationWarning,
                 stacklevel=2,
             )

fastmcp/server/dependencies.py

@@ -5,6 +5,9 @@ from typing import TYPE_CHECKING
 from mcp.server.auth.middleware.auth_context import (
     get_access_token as _sdk_get_access_token,
 )
+from mcp.server.auth.provider import (
+    AccessToken as _SDKAccessToken,
+)
 from starlette.requests import Request
 
 from fastmcp.server.auth import AccessToken
@@ -107,17 +110,27 @@ def get_access_token() -> AccessToken | None:
         The access token if an authenticated user is available, None otherwise.
     """
     #
-    obj = _sdk_get_access_token()
-    if obj is None or isinstance(obj, AccessToken):
-        return obj
+    access_token: _SDKAccessToken | None = _sdk_get_access_token()
+
+    if access_token is None or isinstance(access_token, AccessToken):
+        return access_token
 
     # If the object is not a FastMCP AccessToken, convert it to one if the fields are compatible
     # This is a workaround for the case where the SDK returns a different type
     # If it fails, it will raise a TypeError
     try:
-        return AccessToken(**obj.model_dump())
+        access_token_as_dict = access_token.model_dump()
+        return AccessToken(
+            token=access_token_as_dict["token"],
+            client_id=access_token_as_dict["client_id"],
+            scopes=access_token_as_dict["scopes"],
+            # Optional fields
+            expires_at=access_token_as_dict.get("expires_at"),
+            resource_owner=access_token_as_dict.get("resource_owner"),
+            claims=access_token_as_dict.get("claims"),
+        )
     except Exception as e:
         raise TypeError(
-            f"Expected fastmcp.server.auth.auth.AccessToken, got {type(obj).__name__}. "
+            f"Expected fastmcp.server.auth.auth.AccessToken, got {type(access_token).__name__}. "
             "Ensure the SDK is using the correct AccessToken type."
         ) from e

fastmcp/server/http.py

@@ -113,7 +113,7 @@ def create_base_app(
         A Starlette application
     """
     # Always add RequestContextMiddleware as the outermost middleware
-    middleware.append(Middleware(RequestContextMiddleware))
+    middleware.insert(0, Middleware(RequestContextMiddleware))
 
     return StarletteWithLifespan(
         routes=routes,

fastmcp/server/middleware/logging.py

@@ -16,7 +16,131 @@ def default_serializer(data: Any) -> str:
     return pydantic_core.to_json(data, fallback=str).decode()
 
 
-class LoggingMiddleware(Middleware):
+class BaseLoggingMiddleware(Middleware):
+    """Base class for logging middleware."""
+
+    logger: Logger
+    log_level: int
+    include_payloads: bool
+    include_payload_length: bool
+    estimate_payload_tokens: bool
+    max_payload_length: int | None
+    methods: list[str] | None
+    structured_logging: bool
+    payload_serializer: Callable[[Any], str] | None
+
+    def _serialize_payload(self, context: MiddlewareContext[Any]) -> str:
+        payload: str
+
+        if not self.payload_serializer:
+            payload = default_serializer(context.message)
+        else:
+            try:
+                payload = self.payload_serializer(context.message)
+            except Exception as e:
+                self.logger.warning(
+                    f"Failed to serialize payload due to {e}: {context.type} {context.method} {context.source}."
+                )
+                payload = default_serializer(context.message)
+
+        return payload
+
+    def _format_message(self, message: dict[str, str | int]) -> str:
+        """Format a message for logging."""
+        if self.structured_logging:
+            return json.dumps(message)
+        else:
+            return " ".join([f"{k}={v}" for k, v in message.items()])
+
+    def _get_timestamp_from_context(self, context: MiddlewareContext[Any]) -> str:
+        """Get a timestamp from the context."""
+        return context.timestamp.isoformat()
+
+    def _create_before_message(
+        self, context: MiddlewareContext[Any], event: str
+    ) -> dict[str, str | int]:
+        message = self._create_base_message(context, event)
+
+        if (
+            self.include_payloads
+            or self.include_payload_length
+            or self.estimate_payload_tokens
+        ):
+            payload = self._serialize_payload(context)
+
+            if self.include_payload_length or self.estimate_payload_tokens:
+                payload_length = len(payload)
+                payload_tokens = payload_length // 4
+                if self.estimate_payload_tokens:
+                    message["payload_tokens"] = payload_tokens
+                if self.include_payload_length:
+                    message["payload_length"] = payload_length
+
+            if self.max_payload_length and len(payload) > self.max_payload_length:
+                payload = payload[: self.max_payload_length] + "..."
+
+            if self.include_payloads:
+                message["payload"] = payload
+                message["payload_type"] = type(context.message).__name__
+
+        return message
+
+    def _create_after_message(
+        self, context: MiddlewareContext[Any], event: str
+    ) -> dict[str, str | int]:
+        return self._create_base_message(context, event)
+
+    def _create_base_message(
+        self,
+        context: MiddlewareContext[Any],
+        event: str,
+    ) -> dict[str, str | int]:
+        """Format a message for logging."""
+
+        parts: dict[str, str | int] = {
+            "event": event,
+            "timestamp": self._get_timestamp_from_context(context),
+            "method": context.method or "unknown",
+            "type": context.type,
+            "source": context.source,
+        }
+
+        return parts
+
+    async def on_message(
+        self, context: MiddlewareContext[Any], call_next: CallNext[Any, Any]
+    ) -> Any:
+        """Log all messages."""
+
+        if self.methods and context.method not in self.methods:
+            return await call_next(context)
+
+        request_start_log_message = self._create_before_message(
+            context, "request_start"
+        )
+
+        formatted_message = self._format_message(request_start_log_message)
+        self.logger.log(self.log_level, f"Processing message: {formatted_message}")
+
+        try:
+            result = await call_next(context)
+
+            request_success_log_message = self._create_after_message(
+                context, "request_success"
+            )
+
+            formatted_message = self._format_message(request_success_log_message)
+            self.logger.log(self.log_level, f"Completed message: {formatted_message}")
+
+            return result
+        except Exception as e:
+            self.logger.log(
+                logging.ERROR, f"Failed message: {context.method or 'unknown'} - {e}"
+            )
+            raise
+
+
+class LoggingMiddleware(BaseLoggingMiddleware):
     """Middleware that provides comprehensive request and response logging.
 
     Logs all MCP messages with configurable detail levels. Useful for debugging,
@@ -37,9 +161,12 @@ class LoggingMiddleware(Middleware):
 
     def __init__(
         self,
+        *,
         logger: logging.Logger | None = None,
         log_level: int = logging.INFO,
         include_payloads: bool = False,
+        include_payload_length: bool = False,
+        estimate_payload_tokens: bool = False,
         max_payload_length: int = 1000,
         methods: list[str] | None = None,
         payload_serializer: Callable[[Any], str] | None = None,
@@ -50,68 +177,25 @@ class LoggingMiddleware(Middleware):
             logger: Logger instance to use. If None, creates a logger named 'fastmcp.requests'
             log_level: Log level for messages (default: INFO)
             include_payloads: Whether to include message payloads in logs
+            include_payload_length: Whether to include response size in logs
+            estimate_payload_tokens: Whether to estimate response tokens
             max_payload_length: Maximum length of payload to log (prevents huge logs)
             methods: List of methods to log. If None, logs all methods.
+            payload_serializer: Callable that converts objects to a JSON string for the
+                payload. If not provided, uses FastMCP's default tool serializer.
         """
         self.logger: Logger = logger or logging.getLogger("fastmcp.requests")
-        self.log_level: int = log_level
+        self.log_level = log_level
         self.include_payloads: bool = include_payloads
+        self.include_payload_length: bool = include_payload_length
+        self.estimate_payload_tokens: bool = estimate_payload_tokens
         self.max_payload_length: int = max_payload_length
         self.methods: list[str] | None = methods
         self.payload_serializer: Callable[[Any], str] | None = payload_serializer
+        self.structured_logging: bool = False
 
-    def _format_message(self, context: MiddlewareContext[Any]) -> str:
-        """Format a message for logging."""
-        parts = [
-            f"source={context.source}",
-            f"type={context.type}",
-            f"method={context.method or 'unknown'}",
-        ]
-
-        if self.include_payloads:
-            payload: str
-
-            if not self.payload_serializer:
-                payload = default_serializer(context.message)
-            else:
-                try:
-                    payload = self.payload_serializer(context.message)
-                except Exception as e:
-                    self.logger.warning(
-                        f"Failed {e} to serialize payload: {context.type} {context.method} {context.source}."
-                    )
-                    payload = default_serializer(context.message)
-
-            if len(payload) > self.max_payload_length:
-                payload = payload[: self.max_payload_length] + "..."
 
-            parts.append(f"payload={payload}")
-        return " ".join(parts)
-
-    async def on_message(
-        self, context: MiddlewareContext[Any], call_next: CallNext[Any, Any]
-    ) -> Any:
-        """Log all messages."""
-        message_info = self._format_message(context)
-        if self.methods and context.method not in self.methods:
-            return await call_next(context)
-
-        self.logger.log(self.log_level, f"Processing message: {message_info}")
-
-        try:
-            result = await call_next(context)
-            self.logger.log(
-                self.log_level, f"Completed message: {context.method or 'unknown'}"
-            )
-            return result
-        except Exception as e:
-            self.logger.log(
-                logging.ERROR, f"Failed message: {context.method or 'unknown'} - {e}"
-            )
-            raise
-
-
-class StructuredLoggingMiddleware(Middleware):
+class StructuredLoggingMiddleware(BaseLoggingMiddleware):
     """Middleware that provides structured JSON logging for better log analysis.
 
     Outputs structured logs that are easier to parse and analyze with log
@@ -129,9 +213,12 @@ class StructuredLoggingMiddleware(Middleware):
 
     def __init__(
         self,
+        *,
         logger: logging.Logger | None = None,
         log_level: int = logging.INFO,
         include_payloads: bool = False,
+        include_payload_length: bool = False,
+        estimate_payload_tokens: bool = False,
         methods: list[str] | None = None,
         payload_serializer: Callable[[Any], str] | None = None,
     ):
@@ -141,74 +228,18 @@ class StructuredLoggingMiddleware(Middleware):
             logger: Logger instance to use. If None, creates a logger named 'fastmcp.structured'
             log_level: Log level for messages (default: INFO)
             include_payloads: Whether to include message payloads in logs
+            include_payload_length: Whether to include payload size in logs
+            estimate_payload_tokens: Whether to estimate token count using length // 4
             methods: List of methods to log. If None, logs all methods.
-            serializer: Callable that converts objects to a JSON string for the
+            payload_serializer: Callable that converts objects to a JSON string for the
                 payload. If not provided, uses FastMCP's default tool serializer.
         """
         self.logger: Logger = logger or logging.getLogger("fastmcp.structured")
         self.log_level: int = log_level
         self.include_payloads: bool = include_payloads
+        self.include_payload_length: bool = include_payload_length
+        self.estimate_payload_tokens: bool = estimate_payload_tokens
         self.methods: list[str] | None = methods
         self.payload_serializer: Callable[[Any], str] | None = payload_serializer
-
-    def _create_log_entry(
-        self, context: MiddlewareContext[Any], event: str, **extra_fields: Any
-    ) -> dict[str, Any]:
-        """Create a structured log entry."""
-        entry = {
-            "event": event,
-            "timestamp": context.timestamp.isoformat(),
-            "source": context.source,
-            "type": context.type,
-            "method": context.method,
-            **extra_fields,
-        }
-
-        if self.include_payloads:
-            payload: str
-
-            if not self.payload_serializer:
-                payload = default_serializer(context.message)
-            else:
-                try:
-                    payload = self.payload_serializer(context.message)
-                except Exception as e:
-                    self.logger.warning(
-                        f"Failed {str(e)} to serialize payload: {context.type} {context.method} {context.source}."
-                    )
-                    payload = default_serializer(context.message)
-
-            entry["payload"] = payload
-
-        return entry
-
-    async def on_message(
-        self, context: MiddlewareContext[Any], call_next: CallNext[Any, Any]
-    ) -> Any:
-        """Log structured message information."""
-        start_entry = self._create_log_entry(context, "request_start")
-        if self.methods and context.method not in self.methods:
-            return await call_next(context)
-
-        self.logger.log(self.log_level, json.dumps(start_entry))
-
-        try:
-            result = await call_next(context)
-
-            success_entry = self._create_log_entry(
-                context,
-                "request_success",
-                result_type=type(result).__name__ if result else None,
-            )
-            self.logger.log(self.log_level, json.dumps(success_entry))
-
-            return result
-        except Exception as e:
-            error_entry = self._create_log_entry(
-                context,
-                "request_error",
-                error_type=type(e).__name__,
-                error_message=str(e),
-            )
-            self.logger.log(logging.ERROR, json.dumps(error_entry))
-            raise
+        self.max_payload_length: int | None = None
+        self.structured_logging: bool = True

fastmcp/server/middleware/middleware.py

@@ -15,6 +15,7 @@ from typing import (
 )
 
 import mcp.types as mt
+from mcp.server.lowlevel.helper_types import ReadResourceContents
 from typing_extensions import TypeVar
 
 from fastmcp.prompts.prompt import Prompt
@@ -154,8 +155,8 @@ class Middleware:
     async def on_read_resource(
         self,
         context: MiddlewareContext[mt.ReadResourceRequestParams],
-        call_next: CallNext[mt.ReadResourceRequestParams, mt.ReadResourceResult],
-    ) -> mt.ReadResourceResult:
+        call_next: CallNext[mt.ReadResourceRequestParams, list[ReadResourceContents]],
+    ) -> list[ReadResourceContents]:
         return await call_next(context)
 
     async def on_get_prompt(

fastmcp/server/openapi.py

@@ -785,6 +785,7 @@ class FastMCPOpenAPI(FastMCP):
         http_routes = openapi.parse_openapi_to_http_routes(openapi_spec)
 
         # Process routes
+        num_excluded = 0
         route_maps = (route_maps or []) + DEFAULT_ROUTE_MAPPINGS
         for route in http_routes:
             # Determine route type based on mappings or default rules
@@ -823,8 +824,11 @@ class FastMCPOpenAPI(FastMCP):
                 self._create_openapi_template(route, component_name, tags=route_tags)
             elif route_type == MCPType.EXCLUDE:
                 logger.info(f"Excluding route: {route.method} {route.path}")
+                num_excluded += 1
 
-        logger.info(f"Created FastMCP OpenAPI server with {len(http_routes)} routes")
+        logger.info(
+            f"Created FastMCP OpenAPI server with {len(http_routes) - num_excluded} routes"
+        )
 
     def _generate_default_name(
         self, route: openapi.HTTPRoute, mcp_names_map: dict[str, str] | None = None