fastmcp 2.3.1__py3-none-any.whl → 2.3.3__py3-none-any.whl

fastmcp/cli/cli.py

@@ -327,14 +327,14 @@ def run(
         typer.Option(
             "--transport",
             "-t",
-            help="Transport protocol to use (stdio or sse)",
+            help="Transport protocol to use (stdio, streamable-http, or sse)",
         ),
     ] = None,
     host: Annotated[
         str | None,
         typer.Option(
             "--host",
-            help="Host to bind to when using sse transport (default: 127.0.0.1)",
+            help="Host to bind to when using http transport (default: 127.0.0.1)",
         ),
     ] = None,
     port: Annotated[
@@ -342,7 +342,7 @@ def run(
         typer.Option(
             "--port",
             "-p",
-            help="Port to bind to when using sse transport (default: 8000)",
+            help="Port to bind to when using http transport (default: 8000)",
         ),
     ] = None,
     log_level: Annotated[
@@ -350,20 +350,19 @@ def run(
         typer.Option(
             "--log-level",
             "-l",
-            help="Log level for sse transport (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+            help="Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
         ),
     ] = None,
 ) -> None:
     """Run a MCP server.
 
-    The server can be specified in two ways:\n
+    The server can be specified in two ways:
     1. Module approach: server.py - runs the module directly, expecting a server.run() call.\n
     2. Import approach: server.py:app - imports and runs the specified server object.\n\n
 
     Note: This command runs the server directly. You are responsible for ensuring
-    all dependencies are available.\n
-    For dependency management, use `mcp install` or `mcp dev` instead.
-    """  # noqa: E501
+    all dependencies are available.
+    """
     file, server_object = _parse_file_path(file_spec)
 
     logger.debug(

fastmcp/server/http.py

@@ -3,7 +3,7 @@ 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 typing import TYPE_CHECKING
 
 from mcp.server.auth.middleware.auth_context import AuthContextMiddleware
 from mcp.server.auth.middleware.bearer_auth import (
@@ -19,7 +19,7 @@ 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.routing import BaseRoute, Mount, Route
 from starlette.types import Receive, Scope, Send
 
 from fastmcp.low_level.sse_server_transport import SseServerTransport
@@ -64,7 +64,7 @@ class RequestContextMiddleware:
 def setup_auth_middleware_and_routes(
     auth_server_provider: OAuthAuthorizationServerProvider | None,
     auth_settings: AuthSettings | None,
-) -> tuple[list[Middleware], list[Route | Mount], list[str]]:
+) -> tuple[list[Middleware], list[BaseRoute], list[str]]:
     """Set up authentication middleware and routes if auth is enabled.
 
     Args:
@@ -75,7 +75,7 @@ def setup_auth_middleware_and_routes(
         Tuple of (middleware, auth_routes, required_scopes)
     """
     middleware: list[Middleware] = []
-    auth_routes: list[Route | Mount] = []
+    auth_routes: list[BaseRoute] = []
     required_scopes: list[str] = []
 
     if auth_server_provider:
@@ -108,7 +108,7 @@ def setup_auth_middleware_and_routes(
 
 
 def create_base_app(
-    routes: list[Route | Mount],
+    routes: list[BaseRoute],
     middleware: list[Middleware],
     debug: bool = False,
     lifespan: Callable | None = None,
@@ -142,7 +142,8 @@ def create_sse_app(
     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,
+    routes: list[BaseRoute] | None = None,
+    middleware: list[Middleware] | None = None,
 ) -> Starlette:
     """Return an instance of the SSE server app.
 
@@ -153,11 +154,15 @@ def create_sse_app(
         auth_server_provider: Optional auth provider
         auth_settings: Optional auth settings
         debug: Whether to enable debug mode
-        additional_routes: Optional list of custom routes
-
+        routes: Optional list of custom routes
+        middleware: Optional list of middleware
     Returns:
         A Starlette application with RequestContextMiddleware
     """
+
+    server_routes: list[BaseRoute] = []
+    server_middleware: list[Middleware] = []
+
     # Set up SSE transport
     sse = SseServerTransport(message_path)
 
@@ -172,24 +177,24 @@ def create_sse_app(
         return Response()
 
     # Get auth middleware and routes
-    middleware, auth_routes, required_scopes = setup_auth_middleware_and_routes(
+    auth_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()
+    server_routes.extend(auth_routes)
+    server_middleware.extend(auth_middleware)
 
     # Add SSE routes with or without auth
     if auth_server_provider:
         # Auth is enabled, wrap endpoints with RequireAuthMiddleware
-        routes.append(
+        server_routes.append(
             Route(
                 sse_path,
                 endpoint=RequireAuthMiddleware(handle_sse, required_scopes),
                 methods=["GET"],
             )
         )
-        routes.append(
+        server_routes.append(
             Mount(
                 message_path,
                 app=RequireAuthMiddleware(sse.handle_post_message, required_scopes),
@@ -200,14 +205,14 @@ def create_sse_app(
         async def sse_endpoint(request: Request) -> Response:
             return await handle_sse(request.scope, request.receive, request._send)  # type: ignore[reportPrivateUsage]
 
-        routes.append(
+        server_routes.append(
             Route(
                 sse_path,
                 endpoint=sse_endpoint,
                 methods=["GET"],
             )
         )
-        routes.append(
+        server_routes.append(
             Mount(
                 message_path,
                 app=sse.handle_post_message,
@@ -215,13 +220,17 @@ def create_sse_app(
         )
 
     # Add custom routes with lowest precedence
-    if additional_routes:
-        routes.extend(cast(list[Route | Mount], additional_routes))
+    if routes:
+        server_routes.extend(routes)
+
+    # Add middleware
+    if middleware:
+        server_middleware.extend(middleware)
 
     # Create and return the app
     return create_base_app(
-        routes=routes,
-        middleware=middleware,
+        routes=server_routes,
+        middleware=server_middleware,
         debug=debug,
     )
 
@@ -235,7 +244,8 @@ def create_streamable_http_app(
     json_response: bool = False,
     stateless_http: bool = False,
     debug: bool = False,
-    additional_routes: list[Route] | list[Mount] | list[Route | Mount] | None = None,
+    routes: list[BaseRoute] | None = None,
+    middleware: list[Middleware] | None = None,
 ) -> Starlette:
     """Return an instance of the StreamableHTTP server app.
 
@@ -248,11 +258,15 @@ def create_streamable_http_app(
         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
+        routes: Optional list of custom routes
+        middleware: Optional list of middleware
 
     Returns:
         A Starlette application with StreamableHTTP support
     """
+    server_routes: list[BaseRoute] = []
+    server_middleware: list[Middleware] = []
+
     # Create session manager using the provided event store
     session_manager = StreamableHTTPSessionManager(
         app=server._mcp_server,
@@ -268,17 +282,17 @@ def create_streamable_http_app(
         await session_manager.handle_request(scope, receive, send)
 
     # Get auth middleware and routes
-    middleware, auth_routes, required_scopes = setup_auth_middleware_and_routes(
+    auth_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()
+    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
-        routes.append(
+        server_routes.append(
             Mount(
                 streamable_http_path,
                 app=RequireAuthMiddleware(handle_streamable_http, required_scopes),
@@ -286,7 +300,7 @@ def create_streamable_http_app(
         )
     else:
         # No auth required
-        routes.append(
+        server_routes.append(
             Mount(
                 streamable_http_path,
                 app=handle_streamable_http,
@@ -294,8 +308,12 @@ def create_streamable_http_app(
         )
 
     # Add custom routes with lowest precedence
-    if additional_routes:
-        routes.extend(cast(list[Route | Mount], additional_routes))
+    if routes:
+        server_routes.extend(routes)
+
+    # Add middleware
+    if middleware:
+        server_middleware.extend(middleware)
 
     # Create a lifespan manager to start and stop the session manager
     @asynccontextmanager
@@ -305,8 +323,8 @@ def create_streamable_http_app(
 
     # Create and return the app with lifespan
     return create_base_app(
-        routes=routes,
-        middleware=middleware,
+        routes=server_routes,
+        middleware=server_middleware,
         debug=debug,
         lifespan=lifespan,
     )

fastmcp/server/server.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import datetime
+import inspect
+import warnings
 from collections.abc import AsyncIterator, Awaitable, Callable
 from contextlib import (
     AbstractAsyncContextManager,
@@ -35,9 +37,10 @@ from mcp.types import ResourceTemplate as MCPResourceTemplate
 from mcp.types import Tool as MCPTool
 from pydantic import AnyUrl
 from starlette.applications import Starlette
+from starlette.middleware import Middleware
 from starlette.requests import Request
 from starlette.responses import Response
-from starlette.routing import Route
+from starlette.routing import BaseRoute, Route
 
 import fastmcp.server
 import fastmcp.settings
@@ -147,7 +150,7 @@ class FastMCP(Generic[LifespanResultT]):
             )
         self._auth_server_provider = auth_server_provider
 
-        self._additional_http_routes: list[Route] = []
+        self._additional_http_routes: list[BaseRoute] = []
         self.dependencies = self.settings.dependencies
 
         # Set up MCP protocol handlers
@@ -169,7 +172,7 @@ class FastMCP(Generic[LifespanResultT]):
 
     async def run_async(
         self,
-        transport: Literal["stdio", "sse", "streamable-http"] | None = None,
+        transport: Literal["stdio", "streamable-http", "sse"] | None = None,
         **transport_kwargs: Any,
     ) -> None:
         """Run the FastMCP server asynchronously.
@@ -179,19 +182,21 @@ class FastMCP(Generic[LifespanResultT]):
         """
         if transport is None:
             transport = "stdio"
-        if transport not in ["stdio", "sse", "streamable-http"]:
+        if transport not in ["stdio", "streamable-http", "sse"]:
             raise ValueError(f"Unknown transport: {transport}")
 
         if transport == "stdio":
             await self.run_stdio_async(**transport_kwargs)
+        elif transport == "streamable-http":
+            await self.run_http_async(transport="streamable-http", **transport_kwargs)
         elif transport == "sse":
-            await self.run_sse_async(**transport_kwargs)
-        else:  # transport == "streamable-http"
-            await self.run_streamable_http_async(**transport_kwargs)
+            await self.run_http_async(transport="sse", **transport_kwargs)
+        else:
+            raise ValueError(f"Unknown transport: {transport}")
 
     def run(
         self,
-        transport: Literal["stdio", "sse", "streamable-http"] | None = None,
+        transport: Literal["stdio", "streamable-http", "sse"] | None = None,
         **transport_kwargs: Any,
     ) -> None:
         """Run the FastMCP server. Note this is a synchronous function.
@@ -713,22 +718,31 @@ class FastMCP(Generic[LifespanResultT]):
                 self._mcp_server.create_initialization_options(),
             )
 
-    async def run_sse_async(
+    async def run_http_async(
         self,
+        transport: Literal["streamable-http", "sse"] = "streamable-http",
         host: str | None = None,
         port: int | None = None,
         log_level: str | None = None,
         path: str | None = None,
-        message_path: str | None = None,
         uvicorn_config: dict | None = None,
     ) -> None:
-        """Run the server using SSE transport."""
+        """Run the server using HTTP transport.
+
+        Args:
+            transport: Transport protocol to use - either "streamable-http" (default) or "sse"
+            host: Host address to bind to (defaults to settings.host)
+            port: Port to bind to (defaults to settings.port)
+            log_level: Log level for the server (defaults to settings.log_level)
+            path: Path for the endpoint (defaults to settings.streamable_http_path or settings.sse_path)
+            uvicorn_config: Additional configuration for the Uvicorn server
+        """
         uvicorn_config = uvicorn_config or {}
-        # the SSE app hangs even when a signal is sent, so we disable the
-        # timeout to make it possible to close immediately. see
-        # https://github.com/jlowin/fastmcp/issues/296
         uvicorn_config.setdefault("timeout_graceful_shutdown", 0)
-        app = self.sse_app(path=path, message_path=message_path)
+        # lifespan is required for streamable http
+        uvicorn_config["lifespan"] = "on"
+
+        app = self.http_app(path=path, transport=transport)
 
         config = uvicorn.Config(
             app,
@@ -740,12 +754,58 @@ class FastMCP(Generic[LifespanResultT]):
         server = uvicorn.Server(config)
         await server.serve()
 
+    async def run_sse_async(
+        self,
+        host: str | None = None,
+        port: int | None = None,
+        log_level: str | None = None,
+        path: str | None = None,
+        message_path: str | None = None,
+        uvicorn_config: dict | None = None,
+    ) -> None:
+        """Run the server using SSE transport."""
+        warnings.warn(
+            inspect.cleandoc(
+                """
+                The run_sse_async method is deprecated. Use run_http_async for a
+                modern (non-SSE) alternative, or create an SSE app with
+                `fastmcp.server.http.create_sse_app` and run it directly.
+                """
+            ),
+            DeprecationWarning,
+        )
+        await self.run_http_async(
+            transport="sse",
+            host=host,
+            port=port,
+            log_level=log_level,
+            path=path,
+            uvicorn_config=uvicorn_config,
+        )
+
     def sse_app(
         self,
         path: str | None = None,
         message_path: str | None = None,
+        middleware: list[Middleware] | None = None,
     ) -> Starlette:
-        """Return an instance of the SSE server app."""
+        """
+        Create a Starlette app for the SSE server.
+
+        Args:
+            path: The path to the SSE endpoint
+            message_path: The path to the message endpoint
+            middleware: A list of middleware to apply to the app
+        """
+        warnings.warn(
+            inspect.cleandoc(
+                """
+                The sse_app method is deprecated. Use http_app as a modern (non-SSE)
+                alternative, or call `fastmcp.server.http.create_sse_app` directly.
+                """
+            ),
+            DeprecationWarning,
+        )
         return create_sse_app(
             server=self,
             message_path=message_path or self.settings.message_path,
@@ -753,24 +813,70 @@ class FastMCP(Generic[LifespanResultT]):
             auth_server_provider=self._auth_server_provider,
             auth_settings=self.settings.auth,
             debug=self.settings.debug,
-            additional_routes=self._additional_http_routes,
+            routes=self._additional_http_routes,
+            middleware=middleware,
         )
 
-    def streamable_http_app(self, path: str | None = None) -> Starlette:
-        """Return an instance of the StreamableHTTP server app."""
-        from fastmcp.server.http import create_streamable_http_app
+    def streamable_http_app(
+        self,
+        path: str | None = None,
+        middleware: list[Middleware] | None = None,
+    ) -> Starlette:
+        """
+        Create a Starlette app for the StreamableHTTP server.
 
-        return create_streamable_http_app(
-            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,
-            json_response=self.settings.json_response,
-            stateless_http=self.settings.stateless_http,
-            debug=self.settings.debug,
-            additional_routes=self._additional_http_routes,
+        Args:
+            path: The path to the StreamableHTTP endpoint
+            middleware: A list of middleware to apply to the app
+        """
+        warnings.warn(
+            "The streamable_http_app method is deprecated. Use http_app() instead.",
+            DeprecationWarning,
         )
+        return self.http_app(path=path, middleware=middleware)
+
+    def http_app(
+        self,
+        path: str | None = None,
+        middleware: list[Middleware] | None = None,
+        transport: Literal["streamable-http", "sse"] = "streamable-http",
+    ) -> Starlette:
+        """Create a Starlette app using the specified HTTP transport.
+
+        Args:
+            path: The path for the HTTP endpoint
+            middleware: A list of middleware to apply to the app
+            transport: Transport protocol to use - either "streamable-http" (default) or "sse"
+
+        Returns:
+            A Starlette application configured with the specified transport
+        """
+        from fastmcp.server.http import create_streamable_http_app
+
+        if transport == "streamable-http":
+            return create_streamable_http_app(
+                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,
+                json_response=self.settings.json_response,
+                stateless_http=self.settings.stateless_http,
+                debug=self.settings.debug,
+                routes=self._additional_http_routes,
+                middleware=middleware,
+            )
+        elif transport == "sse":
+            return create_sse_app(
+                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,
+                debug=self.settings.debug,
+                routes=self._additional_http_routes,
+                middleware=middleware,
+            )
 
     async def run_streamable_http_async(
         self,
@@ -780,23 +886,18 @@ class FastMCP(Generic[LifespanResultT]):
         path: str | None = None,
         uvicorn_config: dict | None = None,
     ) -> None:
-        """Run the server using StreamableHTTP transport."""
-        uvicorn_config = uvicorn_config or {}
-        uvicorn_config.setdefault("timeout_graceful_shutdown", 0)
-
-        app = self.streamable_http_app(path=path)
-
-        config = uvicorn.Config(
-            app,
-            host=host or self.settings.host,
-            port=port or self.settings.port,
-            log_level=log_level or self.settings.log_level.lower(),
-            # lifespan is required for streamable http
-            lifespan="on",
-            **uvicorn_config,
+        warnings.warn(
+            "The run_streamable_http_async method is deprecated. Use run_http_async instead.",
+            DeprecationWarning,
+        )
+        await self.run_http_async(
+            transport="streamable-http",
+            host=host,
+            port=port,
+            log_level=log_level,
+            path=path,
+            uvicorn_config=uvicorn_config,
         )
-        server = uvicorn.Server(config)
-        await server.serve()
 
     def mount(
         self,
@@ -993,11 +1094,13 @@ class FastMCP(Generic[LifespanResultT]):
 
 def _validate_resource_prefix(prefix: str) -> None:
     valid_resource = "resource://path/to/resource"
+    test_case = f"{prefix}{valid_resource}"
     try:
-        AnyUrl(f"{prefix}{valid_resource}")
+        AnyUrl(test_case)
     except pydantic.ValidationError as e:
         raise ValueError(
-            f"Resource prefix or separator would result in an invalid resource URI: {e}"
+            "Resource prefix or separator would result in an "
+            f"invalid resource URI (test case was {test_case!r}): {e}"
         )
 
 

fastmcp/utilities/tests.py

@@ -55,7 +55,7 @@ def temporary_settings(**kwargs: Any):
 def _run_server(mcp_server: FastMCP, transport: Literal["sse"], port: int) -> None:
     # Some Starlette apps are not pickleable, so we need to create them here based on the indicated transport
     if transport == "sse":
-        app = mcp_server.sse_app()
+        app = mcp_server.http_app(transport="sse")
     else:
         raise ValueError(f"Invalid transport: {transport}")
     uvicorn_server = uvicorn.Server(
@@ -71,7 +71,7 @@ def _run_server(mcp_server: FastMCP, transport: Literal["sse"], port: int) -> No
 
 @contextmanager
 def run_server_in_process(
-    server_fn: Callable[[str, int], None],
+    server_fn: Callable[[str, int], None], *args
 ) -> Generator[str, None, None]:
     """
     Context manager that runs a Starlette app in a separate process and returns the
@@ -88,7 +88,9 @@ def run_server_in_process(
         s.bind((host, 0))
         port = s.getsockname()[1]
 
-    proc = multiprocessing.Process(target=server_fn, args=(host, port), daemon=True)
+    proc = multiprocessing.Process(
+        target=server_fn, args=(host, port, *args), daemon=True
+    )
     proc.start()
 
     # Wait for server to be running

{fastmcp-2.3.1.dist-info → fastmcp-2.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.3.1
+Version: 2.3.3
 Summary: The fast, Pythonic way to build MCP servers.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -44,7 +44,7 @@ Description-Content-Type: text/markdown
 > [!NOTE]
 > #### FastMCP 2.0 & The Official MCP SDK
 >
-> Recognize the `FastMCP` name? You might have used the version integrated into the [official MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk), which was based on **FastMCP 1.0**.
+> Recognize the `FastMCP` name? You might have seen the version that was contributed to the [official MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk), which was based on **FastMCP 1.0**.
 >
 > **Welcome to FastMCP 2.0!** This is the actively developed successor, and it significantly expands on 1.0 by introducing powerful client capabilities, server proxying & composition, OpenAPI/FastAPI integration, and more advanced features.
 >

{fastmcp-2.3.1.dist-info → fastmcp-2.3.3.dist-info}/RECORD

@@ -4,7 +4,7 @@ fastmcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastmcp/settings.py,sha256=rDClnYEpYjEl8VsvvVrKp9oaE4YLfNQcMoZ41H_bDL0,2968
 fastmcp/cli/__init__.py,sha256=Ii284TNoG5lxTP40ETMGhHEq3lQZWxu9m9JuU57kUpQ,87
 fastmcp/cli/claude.py,sha256=IAlcZ4qZKBBj09jZUMEx7EANZE_IR3vcu7zOBJmMOuU,4567
-fastmcp/cli/cli.py,sha256=7s5RsV8D_tPs20EJcrCvyO-i69DmV60OiRGD21oEJSI,15728
+fastmcp/cli/cli.py,sha256=Tb-WiIXFZiq4nqlZ6LMXN2iYY30clC4Om_gP89HbJcE,15641
 fastmcp/client/__init__.py,sha256=BXO9NUhntZ5GnUACfaRCzDJ5IzxqFJs8qKG-CRMSco4,490
 fastmcp/client/base.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastmcp/client/client.py,sha256=zfSLWSGqiBoADveKehsAL66CdyGGqmzVHR1q46zfdQY,15479
@@ -35,10 +35,10 @@ fastmcp/resources/types.py,sha256=QPDeka_cM1hmvwW4FeFhqy6BEEi4MlwtpvhWUVWh5Fc,64
 fastmcp/server/__init__.py,sha256=bMD4aQD4yJqLz7-mudoNsyeV8UgQfRAg3PRwPvwTEds,119
 fastmcp/server/context.py,sha256=ykitQygA7zT5prbFTLCuYlnAzuljf_9ErUT0FYBPv3E,8135
 fastmcp/server/dependencies.py,sha256=1utkxFsV37HZcWBwI69JyngVN2ppGO_PEgxUlUHHy_Q,742
-fastmcp/server/http.py,sha256=esmeQZJCOxbvYBwF9gTzniymnL93n09hbjgRpmv-9bw,10076
+fastmcp/server/http.py,sha256=utl7vJkMvKUnKIflCptVWk1oqOi7_sJJHqUl22g4JC8,10473
 fastmcp/server/openapi.py,sha256=0nANnwHJ5VZInNyo2f9ErmO0K3igMv6bwyxf3G-BSls,23473
 fastmcp/server/proxy.py,sha256=LDTjzc_iQj8AldsfMU37flGRAfJic1w6qsherfyHPAA,9622
-fastmcp/server/server.py,sha256=2pwYzjHFlg42Mq8qfjX5VttP1OjVJYNOCbW5H7R0hjk,40826
+fastmcp/server/server.py,sha256=FLcZe-ccCUe5288sdEEPl7xlrKgaVunGhJnq7nv70vc,44483
 fastmcp/tools/__init__.py,sha256=ocw-SFTtN6vQ8fgnlF8iNAOflRmh79xS1xdO0Bc3QPE,96
 fastmcp/tools/tool.py,sha256=HGcHjMecqAeN6eI-IfE_2UBcd1KpTV-VOTFLx9tlbpU,7809
 fastmcp/tools/tool_manager.py,sha256=p2nHyLFgz28tbsLpWOurkbWRU2Z34_HcDohjrvwjI0E,3369
@@ -48,10 +48,10 @@ fastmcp/utilities/decorators.py,sha256=AjhjsetQZF4YOPV5MTZmIxO21iFp_4fDIS3O2_KNC
 fastmcp/utilities/json_schema.py,sha256=mSakhP8bENxhLFMwHJSxJAFllNeByIBDjVohwlpac6w,2026
 fastmcp/utilities/logging.py,sha256=zav8pnFxG_fvGJHUV2XpobmT9WVrmv1mlQBSCz-CPx4,1159
 fastmcp/utilities/openapi.py,sha256=Er3G1MyFwiWVxZXicXtD2j-BvttHEDTi1dgkq1KiBQc,51073
-fastmcp/utilities/tests.py,sha256=uUV-8CkhCe5zZJkxhgJXnxrjJ3Yq7cCMZN8xWKGuqdY,3181
+fastmcp/utilities/tests.py,sha256=mAV2EjDeCbm9V9NsVIUjcmzf93MgDjfj8kMvHpf4vgo,3224
 fastmcp/utilities/types.py,sha256=6CcqAQ1QqCO2HGSFlPS6FO5JRWnacjCcO2-EhyEnZV0,4400
-fastmcp-2.3.1.dist-info/METADATA,sha256=EM2ah3-Gf3_vtum6tbRL4627SfRuugJ0xJdbsNa8EJE,15746
-fastmcp-2.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastmcp-2.3.1.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
-fastmcp-2.3.1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fastmcp-2.3.1.dist-info/RECORD,,
+fastmcp-2.3.3.dist-info/METADATA,sha256=4z9X0B1oEDwqQBFJ7d2_YJtEoj2cKLn6TcJafKxATIE,15754
+fastmcp-2.3.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fastmcp-2.3.3.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
+fastmcp-2.3.3.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fastmcp-2.3.3.dist-info/RECORD,,