fastmcp 2.12.5__py3-none-any.whl → 2.13.2__py3-none-any.whl

fastmcp/utilities/mcp_server_config/__init__.py

@@ -15,11 +15,11 @@ from fastmcp.utilities.mcp_server_config.v1.sources.base import Source
 from fastmcp.utilities.mcp_server_config.v1.sources.filesystem import FileSystemSource
 
 __all__ = [
-    "Source",
     "Deployment",
     "Environment",
-    "UVEnvironment",
-    "MCPServerConfig",
     "FileSystemSource",
+    "MCPServerConfig",
+    "Source",
+    "UVEnvironment",
     "generate_schema",
 ]

fastmcp/utilities/mcp_server_config/v1/environments/base.py

@@ -19,7 +19,6 @@ class Environment(BaseModel, ABC):
         Returns:
             Full command ready for subprocess execution
         """
-        pass
 
     async def prepare(self, output_dir: Path | None = None) -> None:
         """Prepare the environment (optional, can be no-op).
@@ -27,4 +26,4 @@ class Environment(BaseModel, ABC):
         Args:
             output_dir: Directory for persistent environment setup
         """
-        pass  # Default no-op implementation
+        # Default no-op implementation

fastmcp/utilities/mcp_server_config/v1/environments/uv.py

@@ -28,19 +28,19 @@ class UVEnvironment(Environment):
         examples=[["fastmcp>=2.0,<3", "httpx", "pandas>=2.0"]],
     )
 
-    requirements: str | None = Field(
+    requirements: Path | None = Field(
         default=None,
         description="Path to requirements.txt file",
         examples=["requirements.txt", "../requirements/prod.txt"],
     )
 
-    project: str | None = Field(
+    project: Path | None = Field(
         default=None,
         description="Path to project directory containing pyproject.toml",
         examples=[".", "../my-project"],
     )
 
-    editable: list[str] | None = Field(
+    editable: list[Path] | None = Field(
         default=None,
         description="Directories to install in editable mode",
         examples=[[".", "../my-package"], ["/path/to/package"]],
@@ -64,7 +64,7 @@ class UVEnvironment(Environment):
 
         # Add project if specified
         if self.project:
-            args.extend(["--project", str(self.project)])
+            args.extend(["--project", str(self.project.resolve())])
 
         # Add Python version if specified (only if no project, as project has its own Python)
         if self.python and not self.project:
@@ -78,12 +78,12 @@ class UVEnvironment(Environment):
 
         # Add requirements file
         if self.requirements:
-            args.extend(["--with-requirements", str(self.requirements)])
+            args.extend(["--with-requirements", str(self.requirements.resolve())])
 
         # Add editable packages
         if self.editable:
             for editable_path in self.editable:
-                args.extend(["--with-editable", str(editable_path)])
+                args.extend(["--with-editable", str(editable_path.resolve())])
 
         # Add the command
         args.extend(command)

fastmcp/utilities/mcp_server_config/v1/mcp_server_config.py

@@ -217,7 +217,7 @@ class MCPServerConfig(BaseModel):
         """
         if isinstance(v, dict):
             return Deployment(**v)  # type: ignore[arg-type]
-        return cast(Deployment, v)
+        return cast(Deployment, v)  # type: ignore[return-value]
 
     @classmethod
     def from_file(cls, file_path: Path) -> MCPServerConfig:
@@ -291,9 +291,9 @@ class MCPServerConfig(BaseModel):
             environment = UVEnvironment(
                 python=python,
                 dependencies=dependencies,
-                requirements=requirements,
-                project=project,
-                editable=[editable] if editable else None,
+                requirements=Path(requirements) if requirements else None,
+                project=Path(project) if project else None,
+                editable=[Path(editable)] if editable else None,
             )
 
         # Build deployment config if any deployment args provided

fastmcp/utilities/mcp_server_config/v1/schema.json

@@ -250,6 +250,7 @@
         "requirements": {
           "anyOf": [
             {
+              "format": "path",
               "type": "string"
             },
             {
@@ -267,6 +268,7 @@
         "project": {
           "anyOf": [
             {
+              "format": "path",
               "type": "string"
             },
             {
@@ -285,6 +287,7 @@
           "anyOf": [
             {
               "items": {
+                "format": "path",
                 "type": "string"
               },
               "type": "array"

fastmcp/utilities/mcp_server_config/v1/sources/base.py

@@ -17,7 +17,6 @@ class Source(BaseModel, ABC):
         need preparation (e.g., local files), this is a no-op.
         """
         # Default implementation for sources that don't need preparation
-        pass
 
     @abstractmethod
     async def load_server(self) -> Any:

fastmcp/utilities/openapi.py

@@ -175,16 +175,16 @@ class HTTPRoute(FastMCPBaseModel):
 # Export public symbols
 __all__ = [
     "HTTPRoute",
+    "HttpMethod",
+    "JsonSchema",
     "ParameterInfo",
+    "ParameterLocation",
     "RequestBodyInfo",
     "ResponseInfo",
-    "HttpMethod",
-    "ParameterLocation",
-    "JsonSchema",
-    "parse_openapi_to_http_routes",
+    "_handle_nullable_fields",
     "extract_output_schema_from_responses",
     "format_deep_object_parameter",
-    "_handle_nullable_fields",
+    "parse_openapi_to_http_routes",
 ]
 
 # Type variables for generic parser
@@ -321,7 +321,7 @@ class OpenAPIParser(
                         else:
                             # Special handling for components
                             if part == "components" and hasattr(target, "components"):
-                                target = getattr(target, "components")
+                                target = target.components
                             elif hasattr(target, part):  # Fallback check
                                 target = getattr(target, part, None)
                             else:
@@ -1178,10 +1178,10 @@ def _add_null_to_type(schema: dict[str, Any]) -> None:
         elif isinstance(current_type, list):
             # Add null to array if not already present
             if "null" not in current_type:
-                schema["type"] = current_type + ["null"]
+                schema["type"] = [*current_type, "null"]
     elif "oneOf" in schema:
         # Convert oneOf to anyOf with null type
-        schema["anyOf"] = schema.pop("oneOf") + [{"type": "null"}]
+        schema["anyOf"] = [*schema.pop("oneOf"), {"type": "null"}]
     elif "anyOf" in schema:
         # Add null type to anyOf if not already present
         if not any(item.get("type") == "null" for item in schema["anyOf"]):
@@ -1233,7 +1233,7 @@ def _handle_nullable_fields(schema: dict[str, Any] | Any) -> dict[str, Any] | An
 
     # Handle properties nullable fields
     if has_property_nullable_field and "properties" in result:
-        for prop_name, prop_schema in result["properties"].items():
+        for _prop_name, prop_schema in result["properties"].items():
             if isinstance(prop_schema, dict) and "nullable" in prop_schema:
                 nullable_value = prop_schema.pop("nullable")
                 if nullable_value and (
@@ -1371,7 +1371,7 @@ def _combine_schemas(route: HTTPRoute) -> dict[str, Any]:
         if used_refs:
             result["$defs"] = {
                 name: def_schema
-                for name, def_schema in result["$defs"].items()
+                for name, def_schema in result["$defs"].items()  # type: ignore[index]
                 if name in used_refs
             }
         else:
@@ -1556,7 +1556,7 @@ def extract_output_schema_from_responses(
         if used_refs:
             output_schema["$defs"] = {
                 name: def_schema
-                for name, def_schema in output_schema["$defs"].items()
+                for name, def_schema in output_schema["$defs"].items()  # type: ignore[index]
                 if name in used_refs
             }
         else:

fastmcp/utilities/tests.py

@@ -5,8 +5,8 @@ import logging
 import multiprocessing
 import socket
 import time
-from collections.abc import Callable, Generator
-from contextlib import contextmanager
+from collections.abc import AsyncGenerator, Callable, Generator
+from contextlib import asynccontextmanager, contextmanager, suppress
 from typing import TYPE_CHECKING, Any, Literal
 from urllib.parse import parse_qs, urlparse
 
@@ -66,6 +66,7 @@ def _run_server(mcp_server: FastMCP, transport: Literal["sse"], port: int) -> No
             host="127.0.0.1",
             port=port,
             log_level="error",
+            ws="websockets-sansio",
         )
     )
     uvicorn_server.run()
@@ -74,11 +75,11 @@ def _run_server(mcp_server: FastMCP, transport: Literal["sse"], port: int) -> No
 @contextmanager
 def run_server_in_process(
     server_fn: Callable[..., None],
-    *args,
+    *args: Any,
     provide_host_and_port: bool = True,
     host: str = "127.0.0.1",
     port: int | None = None,
-    **kwargs,
+    **kwargs: Any,
 ) -> Generator[str, None, None]:
     """
     Context manager that runs a FastMCP server in a separate process and
@@ -139,6 +140,86 @@ def run_server_in_process(
             raise RuntimeError("Server process failed to terminate even after kill")
 
 
+@asynccontextmanager
+async def run_server_async(
+    server: FastMCP,
+    port: int | None = None,
+    transport: Literal["http", "streamable-http", "sse"] = "http",
+    path: str = "/mcp",
+    host: str = "127.0.0.1",
+) -> AsyncGenerator[str, None]:
+    """
+    Start a FastMCP server as an asyncio task for in-process async testing.
+
+    This is the recommended way to test FastMCP servers. It runs the server
+    as an async task in the same process, eliminating subprocess coordination,
+    sleeps, and cleanup issues.
+
+    Args:
+        server: FastMCP server instance
+        port: Port to bind to (default: find available port)
+        transport: Transport type ("http", "streamable-http", or "sse")
+        path: URL path for the server (default: "/mcp")
+        host: Host to bind to (default: "127.0.0.1")
+
+    Yields:
+        Server URL string
+
+    Example:
+        ```python
+        import pytest
+        from fastmcp import FastMCP, Client
+        from fastmcp.client.transports import StreamableHttpTransport
+        from fastmcp.utilities.tests import run_server_async
+
+        @pytest.fixture
+        async def server():
+            mcp = FastMCP("test")
+
+            @mcp.tool()
+            def greet(name: str) -> str:
+                return f"Hello, {name}!"
+
+            async with run_server_async(mcp) as url:
+                yield url
+
+        async def test_greet(server: str):
+            async with Client(StreamableHttpTransport(server)) as client:
+                result = await client.call_tool("greet", {"name": "World"})
+                assert result.content[0].text == "Hello, World!"
+        ```
+    """
+    import asyncio
+
+    if port is None:
+        port = find_available_port()
+
+    # Wait a tiny bit for the port to be released if it was just used
+    await asyncio.sleep(0.01)
+
+    # Start server as a background task
+    server_task = asyncio.create_task(
+        server.run_http_async(
+            host=host,
+            port=port,
+            transport=transport,
+            path=path,
+            show_banner=False,
+        )
+    )
+
+    # Give the server a moment to start
+    await asyncio.sleep(0.1)
+
+    try:
+        yield f"http://{host}:{port}{path}"
+    finally:
+        # Cleanup: cancel the task
+        server_task.cancel()
+        with suppress(asyncio.CancelledError):
+            await server_task
+
+
 @contextmanager
 def caplog_for_fastmcp(caplog):
     """Context manager to capture logs from FastMCP loggers even when propagation is disabled."""

fastmcp/utilities/types.py

@@ -175,6 +175,55 @@ def find_kwarg_by_type(fn: Callable, kwarg_type: type) -> str | None:
     return None
 
 
+def create_function_without_params(
+    fn: Callable[..., Any], exclude_params: list[str]
+) -> Callable[..., Any]:
+    """
+    Create a new function with the same code but without the specified parameters in annotations.
+
+    This is used to exclude parameters from type adapter processing when they can't be serialized.
+    The excluded parameters are removed from the function's __annotations__ dictionary.
+    """
+    import types
+
+    if inspect.ismethod(fn):
+        actual_func = fn.__func__
+        code = actual_func.__code__  # ty: ignore[unresolved-attribute]
+        globals_dict = actual_func.__globals__  # ty: ignore[unresolved-attribute]
+        name = actual_func.__name__  # ty: ignore[unresolved-attribute]
+        defaults = actual_func.__defaults__  # ty: ignore[unresolved-attribute]
+        closure = actual_func.__closure__  # ty: ignore[unresolved-attribute]
+    else:
+        code = fn.__code__  # ty: ignore[unresolved-attribute]
+        globals_dict = fn.__globals__  # ty: ignore[unresolved-attribute]
+        name = fn.__name__  # ty: ignore[unresolved-attribute]
+        defaults = fn.__defaults__  # ty: ignore[unresolved-attribute]
+        closure = fn.__closure__  # ty: ignore[unresolved-attribute]
+
+    # Create a copy of annotations without the excluded parameters
+    original_annotations = getattr(fn, "__annotations__", {})
+    new_annotations = {
+        k: v for k, v in original_annotations.items() if k not in exclude_params
+    }
+
+    new_func = types.FunctionType(
+        code,
+        globals_dict,
+        name,
+        defaults,
+        closure,
+    )
+    new_func.__dict__.update(fn.__dict__)
+    new_func.__module__ = fn.__module__
+    new_func.__qualname__ = getattr(fn, "__qualname__", fn.__name__)  # ty: ignore[unresolved-attribute]
+    new_func.__annotations__ = new_annotations
+
+    if inspect.ismethod(fn):
+        return types.MethodType(new_func, fn.__self__)
+    else:
+        return new_func
+
+
 class Image:
     """Helper class for returning images from tools."""
 
@@ -190,34 +239,33 @@ class Image:
         if path is not None and data is not None:
             raise ValueError("Only one of path or data can be provided")
 
-        self.path = Path(os.path.expandvars(str(path))).expanduser() if path else None
+        self.path = self._get_expanded_path(path)
         self.data = data
         self._format = format
         self._mime_type = self._get_mime_type()
         self.annotations = annotations
 
+    @staticmethod
+    def _get_expanded_path(path: str | Path | None) -> Path | None:
+        """Expand environment variables and user home in path."""
+        return Path(os.path.expandvars(str(path))).expanduser() if path else None
+
     def _get_mime_type(self) -> str:
         """Get MIME type from format or guess from file extension."""
         if self._format:
             return f"image/{self._format.lower()}"
 
         if self.path:
-            suffix = self.path.suffix.lower()
-            return {
-                ".png": "image/png",
-                ".jpg": "image/jpeg",
-                ".jpeg": "image/jpeg",
-                ".gif": "image/gif",
-                ".webp": "image/webp",
-            }.get(suffix, "application/octet-stream")
+            # Workaround for WEBP in Py3.10
+            mimetypes.add_type("image/webp", ".webp")
+            resp = mimetypes.guess_type(self.path, strict=False)
+            if resp and resp[0] is not None:
+                return resp[0]
+            return "application/octet-stream"
         return "image/png"  # default for raw binary data
 
-    def to_image_content(
-        self,
-        mime_type: str | None = None,
-        annotations: Annotations | None = None,
-    ) -> mcp.types.ImageContent:
-        """Convert to MCP ImageContent."""
+    def _get_data(self) -> str:
+        """Get raw image data as base64-encoded string."""
         if self.path:
             with open(self.path, "rb") as f:
                 data = base64.b64encode(f.read()).decode()
@@ -225,6 +273,15 @@ class Image:
             data = base64.b64encode(self.data).decode()
         else:
             raise ValueError("No image data available")
+        return data
+
+    def to_image_content(
+        self,
+        mime_type: str | None = None,
+        annotations: Annotations | None = None,
+    ) -> mcp.types.ImageContent:
+        """Convert to MCP ImageContent."""
+        data = self._get_data()
 
         return mcp.types.ImageContent(
             type="image",
@@ -233,6 +290,11 @@ class Image:
             annotations=annotations or self.annotations,
         )
 
+    def to_data_uri(self, mime_type: str | None = None) -> str:
+        """Get image as a data URI."""
+        data = self._get_data()
+        return f"data:{mime_type or self._mime_type};base64,{data}"
+
 
 class Audio:
     """Helper class for returning audio from tools."""
@@ -293,7 +355,7 @@ class Audio:
 
 
 class File:
-    """Helper class for returning audio from tools."""
+    """Helper class for returning file data from tools."""
 
     def __init__(
         self,