fastmcp 2.2.10__py3-none-any.whl → 2.3.0__py3-none-any.whl

fastmcp/server/dependencies.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ParamSpec, TypeVar
+
+from starlette.requests import Request
+
+if TYPE_CHECKING:
+    from fastmcp.server.context import Context
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+# --- Context ---
+
+
+def get_context() -> Context:
+    from fastmcp.server.context import _current_context
+
+    context = _current_context.get()
+    if context is None:
+        raise RuntimeError("No active context found.")
+    return context
+
+
+# --- HTTP Request ---
+
+
+def get_http_request() -> Request:
+    from fastmcp.server.http import _current_http_request
+
+    request = _current_http_request.get()
+    if request is None:
+        raise RuntimeError("No active HTTP request found.")
+    return request

fastmcp/server/http.py

@@ -0,0 +1,308 @@
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator, Callable, Generator
+from contextlib import asynccontextmanager, contextmanager
+from contextvars import ContextVar
+from typing import TYPE_CHECKING, cast
+
+from mcp.server.auth.middleware.auth_context import AuthContextMiddleware
+from mcp.server.auth.middleware.bearer_auth import (
+    BearerAuthBackend,
+    RequireAuthMiddleware,
+)
+from mcp.server.auth.provider import OAuthAuthorizationServerProvider
+from mcp.server.auth.routes import create_auth_routes
+from mcp.server.auth.settings import AuthSettings
+from mcp.server.sse import SseServerTransport
+from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
+from starlette.applications import Starlette
+from starlette.middleware import Middleware
+from starlette.middleware.authentication import AuthenticationMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+from starlette.routing import Mount, Route
+from starlette.types import Receive, Scope, Send
+
+from fastmcp.utilities.logging import get_logger
+
+if TYPE_CHECKING:
+    from fastmcp.server.server import FastMCP
+
+logger = get_logger(__name__)
+
+_current_http_request: ContextVar[Request | None] = ContextVar(
+    "http_request",
+    default=None,
+)
+
+
+@contextmanager
+def set_http_request(request: Request) -> Generator[Request, None, None]:
+    token = _current_http_request.set(request)
+    try:
+        yield request
+    finally:
+        _current_http_request.reset(token)
+
+
+class RequestContextMiddleware:
+    """
+    Middleware that stores each request in a ContextVar
+    """
+
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] == "http":
+            with set_http_request(Request(scope)):
+                await self.app(scope, receive, send)
+        else:
+            await self.app(scope, receive, send)
+
+
+def setup_auth_middleware_and_routes(
+    auth_server_provider: OAuthAuthorizationServerProvider | None,
+    auth_settings: AuthSettings | None,
+) -> tuple[list[Middleware], list[Route | Mount], 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
+
+    Returns:
+        Tuple of (middleware, auth_routes, required_scopes)
+    """
+    middleware: list[Middleware] = []
+    auth_routes: list[Route | Mount] = []
+    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_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,
+            )
+        )
+
+    return middleware, auth_routes, required_scopes
+
+
+def create_base_app(
+    routes: list[Route | Mount],
+    middleware: list[Middleware],
+    debug: bool,
+    lifespan: Callable | None = None,
+) -> Starlette:
+    """Create a base Starlette app with common middleware and routes.
+
+    Args:
+        routes: List of routes to include in the app
+        middleware: List of middleware to include in the app
+        debug: Whether to enable debug mode
+        lifespan: Optional lifespan manager for the app
+
+    Returns:
+        A Starlette application
+    """
+    # Always add RequestContextMiddleware as the outermost middleware
+    middleware.append(Middleware(RequestContextMiddleware))
+
+    # Create the app
+    app_kwargs = {
+        "debug": debug,
+        "routes": routes,
+        "middleware": middleware,
+    }
+
+    if lifespan:
+        app_kwargs["lifespan"] = lifespan
+
+    return Starlette(**app_kwargs)
+
+
+def create_sse_app(
+    server: FastMCP,
+    message_path: str,
+    sse_path: str,
+    auth_server_provider: OAuthAuthorizationServerProvider | None = None,
+    auth_settings: AuthSettings | None = None,
+    debug: bool = False,
+    additional_routes: list[Route] | list[Mount] | list[Route | Mount] | None = None,
+) -> Starlette:
+    """Return an instance of the SSE server app.
+
+    Args:
+        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
+        debug: Whether to enable debug mode
+        additional_routes: Optional list of custom routes
+
+    Returns:
+        A Starlette application with RequestContextMiddleware
+    """
+    # Set up SSE transport
+    sse = SseServerTransport(message_path)
+
+    # Create handler for SSE connections
+    async def handle_sse(scope: Scope, receive: Receive, send: Send) -> Response:
+        async with sse.connect_sse(scope, receive, send) as streams:
+            await server._mcp_server.run(
+                streams[0],
+                streams[1],
+                server._mcp_server.create_initialization_options(),
+            )
+        return Response()
+
+    # Get auth middleware and routes
+    middleware, auth_routes, required_scopes = setup_auth_middleware_and_routes(
+        auth_server_provider, auth_settings
+    )
+
+    # Initialize routes with auth routes
+    routes: list[Route | Mount] = auth_routes.copy()
+
+    # Add SSE routes with or without auth
+    if auth_server_provider:
+        # Auth is enabled, wrap endpoints with RequireAuthMiddleware
+        routes.append(
+            Route(
+                sse_path,
+                endpoint=RequireAuthMiddleware(handle_sse, required_scopes),
+                methods=["GET"],
+            )
+        )
+        routes.append(
+            Mount(
+                message_path,
+                app=RequireAuthMiddleware(sse.handle_post_message, required_scopes),
+            )
+        )
+    else:
+        # No auth required
+        async def sse_endpoint(request: Request) -> Response:
+            return await handle_sse(request.scope, request.receive, request._send)  # type: ignore[reportPrivateUsage]
+
+        routes.append(
+            Route(
+                sse_path,
+                endpoint=sse_endpoint,
+                methods=["GET"],
+            )
+        )
+        routes.append(
+            Mount(
+                message_path,
+                app=sse.handle_post_message,
+            )
+        )
+
+    # Add custom routes with lowest precedence
+    if additional_routes:
+        routes.extend(cast(list[Route | Mount], additional_routes))
+
+    # Create and return the app
+    return create_base_app(routes, middleware, debug)
+
+
+def create_streamable_http_app(
+    server: FastMCP,
+    streamable_http_path: str,
+    event_store: None = None,
+    auth_server_provider: OAuthAuthorizationServerProvider | None = None,
+    auth_settings: AuthSettings | None = None,
+    json_response: bool = False,
+    stateless_http: bool = False,
+    debug: bool = False,
+    additional_routes: list[Route] | list[Mount] | list[Route | Mount] | None = None,
+) -> Starlette:
+    """Return an instance of the StreamableHTTP server app.
+
+    Args:
+        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
+        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
+        additional_routes: Optional list of custom routes
+
+    Returns:
+        A Starlette application with StreamableHTTP support
+    """
+    # Create session manager using the provided event store
+    session_manager = StreamableHTTPSessionManager(
+        app=server._mcp_server,
+        event_store=event_store,
+        json_response=json_response,
+        stateless=stateless_http,
+    )
+
+    # Create the ASGI handler
+    async def handle_streamable_http(
+        scope: Scope, receive: Receive, send: Send
+    ) -> None:
+        await session_manager.handle_request(scope, receive, send)
+
+    # Get auth middleware and routes
+    middleware, auth_routes, required_scopes = setup_auth_middleware_and_routes(
+        auth_server_provider, auth_settings
+    )
+
+    # Initialize routes with auth routes
+    routes: list[Route | Mount] = auth_routes.copy()
+
+    # Add StreamableHTTP routes with or without auth
+    if auth_server_provider:
+        # Auth is enabled, wrap endpoint with RequireAuthMiddleware
+        routes.append(
+            Mount(
+                streamable_http_path,
+                app=RequireAuthMiddleware(handle_streamable_http, required_scopes),
+            )
+        )
+    else:
+        # No auth required
+        routes.append(
+            Mount(
+                streamable_http_path,
+                app=handle_streamable_http,
+            )
+        )
+
+    # Add custom routes with lowest precedence
+    if additional_routes:
+        routes.extend(cast(list[Route | Mount], additional_routes))
+
+    # Create a lifespan manager to start and stop the session manager
+    @asynccontextmanager
+    async def lifespan(app: Starlette) -> AsyncGenerator[None, None]:
+        async with session_manager.run():
+            yield
+
+    # Create and return the app with lifespan
+    return create_base_app(routes, middleware, debug, lifespan)

fastmcp/server/openapi.py

@@ -25,9 +25,6 @@ from fastmcp.utilities.openapi import (
 )
 
 if TYPE_CHECKING:
-    from mcp.server.session import ServerSessionT
-    from mcp.shared.context import LifespanContextT
-
     from fastmcp.server import Context
 
 logger = get_logger(__name__)
@@ -132,7 +129,6 @@ class OpenAPITool(Tool):
             description=description,
             parameters=parameters,
             fn=self._execute_request,  # We'll use an instance method instead of a global function
-            context_kwarg="context",  # Default context keyword argument
             tags=tags,
             annotations=annotations,
             serializer=serializer,
@@ -258,12 +254,10 @@ class OpenAPITool(Tool):
             raise ValueError(f"Request error: {str(e)}")
 
     async def run(
-        self,
-        arguments: dict[str, Any],
-        context: Context[ServerSessionT, LifespanContextT] | None = None,
+        self, arguments: dict[str, Any]
     ) -> list[TextContent | ImageContent | EmbeddedResource]:
         """Run the tool with arguments and optional context."""
-        response = await self._execute_request(**arguments, context=context)
+        response = await self._execute_request(**arguments)
         return _convert_to_content(response)
 
 
@@ -292,9 +286,7 @@ class OpenAPIResource(Resource):
         self._route = route
         self._timeout = timeout
 
-    async def read(
-        self, context: Context[ServerSessionT, LifespanContextT] | None = None
-    ) -> str | bytes:
+    async def read(self) -> str | bytes:
         """Fetch the resource data by making an HTTP request."""
         try:
             # Extract path parameters from the URI if present
@@ -399,7 +391,6 @@ class OpenAPIResourceTemplate(ResourceTemplate):
             fn=lambda **kwargs: None,
             parameters=parameters,
             tags=tags,
-            context_kwarg=None,
         )
         self._client = client
         self._route = route
@@ -409,7 +400,7 @@ class OpenAPIResourceTemplate(ResourceTemplate):
         self,
         uri: str,
         params: dict[str, Any],
-        context: Context[ServerSessionT, LifespanContextT] | None = None,
+        context: Context | None = None,
     ) -> Resource:
         """Create a resource with the given parameters."""
         # Generate a URI for this resource instance
@@ -650,7 +641,5 @@ class FastMCPOpenAPI(FastMCP):
 
     async def _mcp_call_tool(self, name: str, arguments: dict[str, Any]) -> Any:
         """Override the call_tool method to return the raw result without converting to content."""
-
-        context = self.get_context()
-        result = await self._tool_manager.call_tool(name, arguments, context=context)
+        result = await self._tool_manager.call_tool(name, arguments)
         return result

fastmcp/server/proxy.py

@@ -27,9 +27,6 @@ from fastmcp.tools.tool import Tool
 from fastmcp.utilities.logging import get_logger
 
 if TYPE_CHECKING:
-    from mcp.server.session import ServerSessionT
-    from mcp.shared.context import LifespanContextT
-
     from fastmcp.server import Context
 
 logger = get_logger(__name__)
@@ -57,7 +54,7 @@ class ProxyTool(Tool):
     async def run(
         self,
         arguments: dict[str, Any],
-        context: Context[ServerSessionT, LifespanContextT] | None = None,
+        context: Context | None = None,
     ) -> list[TextContent | ImageContent | EmbeddedResource]:
         # the client context manager will swallow any exceptions inside a TaskGroup
         # so we return the raw result and raise an exception ourselves
@@ -89,9 +86,7 @@ class ProxyResource(Resource):
             mime_type=resource.mimeType,
         )
 
-    async def read(
-        self, context: Context[ServerSessionT, LifespanContextT] | None = None
-    ) -> str | bytes:
+    async def read(self) -> str | bytes:
         if self._value is not None:
             return self._value
 
@@ -127,7 +122,7 @@ class ProxyTemplate(ResourceTemplate):
         self,
         uri: str,
         params: dict[str, Any],
-        context: Context[ServerSessionT, LifespanContextT] | None = None,
+        context: Context | None = None,
     ) -> ProxyResource:
         # dont use the provided uri, because it may not be the same as the
         # uri_template on the remote server.
@@ -171,11 +166,7 @@ class ProxyPrompt(Prompt):
             fn=_proxy_passthrough,
         )
 
-    async def render(
-        self,
-        arguments: dict[str, Any],
-        context: Context[ServerSessionT, LifespanContextT] | None = None,
-    ) -> list[PromptMessage]:
+    async def render(self, arguments: dict[str, Any]) -> list[PromptMessage]:
         async with self._client:
             result = await self._client.get_prompt(self.name, arguments)
         return result.messages