fastmcp 2.3.4__py3-none-any.whl → 2.4.0__py3-none-any.whl

fastmcp/server/http.py

@@ -10,9 +10,16 @@ from mcp.server.auth.middleware.bearer_auth import (
     BearerAuthBackend,
     RequireAuthMiddleware,
 )
-from mcp.server.auth.provider import OAuthAuthorizationServerProvider
+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
 from starlette.applications import Starlette
 from starlette.middleware import Middleware
@@ -20,9 +27,8 @@ from starlette.middleware.authentication import AuthenticationMiddleware
 from starlette.requests import Request
 from starlette.responses import Response
 from starlette.routing import BaseRoute, Mount, Route
-from starlette.types import Receive, Scope, Send
+from starlette.types import Lifespan, Receive, Scope, Send
 
-from fastmcp.low_level.sse_server_transport import SseServerTransport
 from fastmcp.utilities.logging import get_logger
 
 if TYPE_CHECKING:
@@ -30,12 +36,19 @@ if TYPE_CHECKING:
 
 logger = get_logger(__name__)
 
+
 _current_http_request: ContextVar[Request | None] = ContextVar(
     "http_request",
     default=None,
 )
 
 
+class StarletteWithLifespan(Starlette):
+    @property
+    def lifespan(self) -> Lifespan:
+        return self.router.lifespan_context
+
+
 @contextmanager
 def set_http_request(request: Request) -> Generator[Request, None, None]:
     token = _current_http_request.set(request)
@@ -62,7 +75,10 @@ class RequestContextMiddleware:
 
 
 def setup_auth_middleware_and_routes(
-    auth_server_provider: OAuthAuthorizationServerProvider | None,
+    auth_server_provider: OAuthAuthorizationServerProvider[
+        AuthorizationCodeT, RefreshTokenT, AccessTokenT
+    ]
+    | None,
     auth_settings: AuthSettings | None,
 ) -> tuple[list[Middleware], list[BaseRoute], list[str]]:
     """Set up authentication middleware and routes if auth is enabled.
@@ -112,7 +128,7 @@ def create_base_app(
     middleware: list[Middleware],
     debug: bool = False,
     lifespan: Callable | None = None,
-) -> Starlette:
+) -> StarletteWithLifespan:
     """Create a base Starlette app with common middleware and routes.
 
     Args:
@@ -127,7 +143,7 @@ def create_base_app(
     # Always add RequestContextMiddleware as the outermost middleware
     middleware.append(Middleware(RequestContextMiddleware))
 
-    return Starlette(
+    return StarletteWithLifespan(
         routes=routes,
         middleware=middleware,
         debug=debug,
@@ -136,15 +152,18 @@ def create_base_app(
 
 
 def create_sse_app(
-    server: FastMCP,
+    server: FastMCP[LifespanResultT],
     message_path: str,
     sse_path: str,
-    auth_server_provider: OAuthAuthorizationServerProvider | None = None,
+    auth_server_provider: OAuthAuthorizationServerProvider[
+        AuthorizationCodeT, RefreshTokenT, AccessTokenT
+    ]
+    | None = None,
     auth_settings: AuthSettings | None = None,
     debug: bool = False,
     routes: list[BaseRoute] | None = None,
     middleware: list[Middleware] | None = None,
-) -> Starlette:
+) -> StarletteWithLifespan:
     """Return an instance of the SSE server app.
 
     Args:
@@ -228,25 +247,33 @@ def create_sse_app(
         server_middleware.extend(middleware)
 
     # Create and return the app
-    return create_base_app(
+    app = create_base_app(
         routes=server_routes,
         middleware=server_middleware,
         debug=debug,
     )
+    # Store the FastMCP server instance on the Starlette app state
+    app.state.fastmcp_server = server
+    app.state.path = sse_path
+
+    return app
 
 
 def create_streamable_http_app(
-    server: FastMCP,
+    server: FastMCP[LifespanResultT],
     streamable_http_path: str,
     event_store: None = None,
-    auth_server_provider: OAuthAuthorizationServerProvider | None = None,
+    auth_server_provider: OAuthAuthorizationServerProvider[
+        AuthorizationCodeT, RefreshTokenT, AccessTokenT
+    ]
+    | None = None,
     auth_settings: AuthSettings | None = None,
     json_response: bool = False,
     stateless_http: bool = False,
     debug: bool = False,
     routes: list[BaseRoute] | None = None,
     middleware: list[Middleware] | None = None,
-) -> Starlette:
+) -> StarletteWithLifespan:
     """Return an instance of the StreamableHTTP server app.
 
     Args:
@@ -279,7 +306,29 @@ def create_streamable_http_app(
     async def handle_streamable_http(
         scope: Scope, receive: Receive, send: Send
     ) -> None:
-        await session_manager.handle_request(scope, receive, send)
+        try:
+            await session_manager.handle_request(scope, receive, send)
+        except RuntimeError as e:
+            if str(e) == "Task group is not initialized. Make sure to use run().":
+                logger.error(
+                    f"Original RuntimeError from mcp library: {e}", exc_info=True
+                )
+                new_error_message = (
+                    "FastMCP's StreamableHTTPSessionManager task group was not initialized. "
+                    "This commonly occurs when the FastMCP application's lifespan is not "
+                    "passed to the parent ASGI application (e.g., FastAPI or Starlette). "
+                    "Please ensure you are setting `lifespan=mcp_app.lifespan` in your "
+                    "parent app's constructor, where `mcp_app` is the application instance "
+                    "returned by `fastmcp_instance.http_app()`. \\n"
+                    "For more details, see the FastMCP ASGI integration documentation: "
+                    "https://gofastmcp.com/deployment/asgi"
+                )
+                # Raise a new RuntimeError that includes the original error's message
+                # for full context, but leads with the more helpful guidance.
+                raise RuntimeError(f"{new_error_message}\\nOriginal error: {e}") from e
+            else:
+                # 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(
@@ -322,9 +371,15 @@ def create_streamable_http_app(
             yield
 
     # Create and return the app with lifespan
-    return create_base_app(
+    app = create_base_app(
         routes=server_routes,
         middleware=server_middleware,
         debug=debug,
         lifespan=lifespan,
     )
+    # Store the FastMCP server instance on the Starlette app state
+    app.state.fastmcp_server = server
+
+    app.state.path = streamable_http_path
+
+    return app

fastmcp/server/openapi.py

@@ -47,7 +47,7 @@ class RouteType(enum.Enum):
 class RouteMap:
     """Mapping configuration for HTTP routes to FastMCP component types."""
 
-    methods: list[HttpMethod]
+    methods: list[HttpMethod] | Literal["*"]
     pattern: Pattern[str] | str
     route_type: RouteType
 
@@ -86,7 +86,7 @@ def _determine_route_type(
     # Check mappings in priority order (first match wins)
     for route_map in mappings:
         # Check if the HTTP method matches
-        if route.method in route_map.methods:
+        if route_map.methods == "*" or route.method in route_map.methods:
             # Handle both string patterns and compiled Pattern objects
             if isinstance(route_map.pattern, Pattern):
                 pattern_matches = route_map.pattern.search(route.path)
@@ -171,17 +171,120 @@ class OpenAPITool(Tool):
             raise ToolError(f"Missing required path parameters: {missing_params}")
 
         for param_name, param_value in path_params.items():
+            # Handle array path parameters with style 'simple' (comma-separated)
+            # In OpenAPI, 'simple' is the default style for path parameters
+            param_info = next(
+                (p for p in self._route.parameters if p.name == param_name), None
+            )
+
+            if param_info and isinstance(param_value, list):
+                # Check if schema indicates an array type
+                schema = param_info.schema_
+                is_array = schema.get("type") == "array"
+
+                if is_array:
+                    # Format array values as comma-separated string
+                    # This follows the OpenAPI 'simple' style (default for path)
+                    if all(
+                        isinstance(item, str | int | float | bool)
+                        for item in param_value
+                    ):
+                        # Handle simple array types
+                        path = path.replace(
+                            f"{{{param_name}}}", ",".join(str(v) for v in param_value)
+                        )
+                    else:
+                        # Handle complex array types (containing objects/dicts)
+                        try:
+                            # Try to create a simple representation without Python syntax artifacts
+                            formatted_parts = []
+                            for item in param_value:
+                                if isinstance(item, dict):
+                                    # For objects, serialize key-value pairs
+                                    item_parts = []
+                                    for k, v in item.items():
+                                        item_parts.append(f"{k}:{v}")
+                                    formatted_parts.append(".".join(item_parts))
+                                else:
+                                    # Fallback for other complex types
+                                    formatted_parts.append(str(item))
+
+                            # Join parts with commas
+                            formatted_value = ",".join(formatted_parts)
+                            path = path.replace(f"{{{param_name}}}", formatted_value)
+                        except Exception as e:
+                            logger.warning(
+                                f"Failed to format complex array path parameter '{param_name}': {e}"
+                            )
+                            # Fallback to string representation, but remove Python syntax artifacts
+                            str_value = (
+                                str(param_value)
+                                .replace("[", "")
+                                .replace("]", "")
+                                .replace("'", "")
+                                .replace('"', "")
+                            )
+                            path = path.replace(f"{{{param_name}}}", str_value)
+                    continue
+
+            # Default handling for non-array parameters or non-array schemas
             path = path.replace(f"{{{param_name}}}", str(param_value))
 
         # Prepare query parameters - filter out None and empty strings
-        query_params = {
-            p.name: kwargs.get(p.name)
-            for p in self._route.parameters
-            if p.location == "query"
-            and p.name in kwargs
-            and kwargs.get(p.name) is not None
-            and kwargs.get(p.name) != ""
-        }
+        query_params = {}
+        for p in self._route.parameters:
+            if (
+                p.location == "query"
+                and p.name in kwargs
+                and kwargs.get(p.name) is not None
+                and kwargs.get(p.name) != ""
+            ):
+                param_value = kwargs.get(p.name)
+
+                # Format array query parameters as comma-separated strings
+                # following OpenAPI form style (default for query parameters)
+                if isinstance(param_value, list) and p.schema_.get("type") == "array":
+                    # Get explode parameter from schema, default is True for query parameters
+                    # If explode is True, the array is serialized as separate parameters
+                    # If explode is False, the array is serialized as a comma-separated string
+                    explode = p.schema_.get("explode", True)
+
+                    if explode:
+                        # When explode=True, we pass the array directly, which HTTPX will serialize
+                        # as multiple parameters with the same name
+                        query_params[p.name] = param_value
+                    else:
+                        # For arrays of simple types (strings, numbers, etc.), join with commas
+                        if all(
+                            isinstance(item, str | int | float | bool)
+                            for item in param_value
+                        ):
+                            query_params[p.name] = ",".join(str(v) for v in param_value)
+                        else:
+                            # For complex types, try to create a simpler representation
+                            try:
+                                # Try to create a simple string representation
+                                formatted_parts = []
+                                for item in param_value:
+                                    if isinstance(item, dict):
+                                        # For objects, serialize key-value pairs
+                                        item_parts = []
+                                        for k, v in item.items():
+                                            item_parts.append(f"{k}:{v}")
+                                        formatted_parts.append(".".join(item_parts))
+                                    else:
+                                        formatted_parts.append(str(item))
+
+                                query_params[p.name] = ",".join(formatted_parts)
+                            except Exception as e:
+                                logger.warning(
+                                    f"Failed to format complex array query parameter '{p.name}': {e}"
+                                )
+                                # Fallback to string representation
+                                query_params[p.name] = param_value
+                else:
+                    # Non-array parameters are passed as is
+                    query_params[p.name] = param_value
 
         # Prepare headers - fix typing by ensuring all values are strings
         headers = {}