fastmcp 2.13.0rc3__py3-none-any.whl → 2.13.0.2__py3-none-any.whl

fastmcp/server/server.py

@@ -15,7 +15,11 @@ from collections.abc import (
     Mapping,
     Sequence,
 )
-from contextlib import AbstractAsyncContextManager, AsyncExitStack, asynccontextmanager
+from contextlib import (
+    AbstractAsyncContextManager,
+    AsyncExitStack,
+    asynccontextmanager,
+)
 from dataclasses import dataclass
 from functools import partial
 from pathlib import Path
@@ -150,7 +154,7 @@ class FastMCP(Generic[LifespanResultT]):
         version: str | None = None,
         website_url: str | None = None,
         icons: list[mcp.types.Icon] | None = None,
-        auth: AuthProvider | None | NotSetT = NotSet,
+        auth: AuthProvider | NotSetT | None = NotSet,
         middleware: Sequence[Middleware] | None = None,
         lifespan: LifespanCallable | None = None,
         dependencies: list[str] | None = None,
@@ -1062,10 +1066,10 @@ class FastMCP(Generic[LifespanResultT]):
             try:
                 result = await self._call_tool_middleware(key, arguments)
                 return result.to_mcp_result()
-            except DisabledError:
-                raise NotFoundError(f"Unknown tool: {key}")
-            except NotFoundError:
-                raise NotFoundError(f"Unknown tool: {key}")
+            except DisabledError as e:
+                raise NotFoundError(f"Unknown tool: {key}") from e
+            except NotFoundError as e:
+                raise NotFoundError(f"Unknown tool: {key}") from e
 
     async def _call_tool_middleware(
         self,
@@ -1142,12 +1146,12 @@ class FastMCP(Generic[LifespanResultT]):
                 return list[ReadResourceContents](
                     await self._read_resource_middleware(uri)
                 )
-            except DisabledError:
+            except DisabledError as e:
                 # convert to NotFoundError to avoid leaking resource presence
-                raise NotFoundError(f"Unknown resource: {str(uri)!r}")
-            except NotFoundError:
+                raise NotFoundError(f"Unknown resource: {str(uri)!r}") from e
+            except NotFoundError as e:
                 # standardize NotFound message
-                raise NotFoundError(f"Unknown resource: {str(uri)!r}")
+                raise NotFoundError(f"Unknown resource: {str(uri)!r}") from e
 
     async def _read_resource_middleware(
         self,
@@ -1158,10 +1162,7 @@ class FastMCP(Generic[LifespanResultT]):
         """
 
         # Convert string URI to AnyUrl if needed
-        if isinstance(uri, str):
-            uri_param = AnyUrl(uri)
-        else:
-            uri_param = uri
+        uri_param = AnyUrl(uri) if isinstance(uri, str) else uri
 
         mw_context = MiddlewareContext(
             message=mcp.types.ReadResourceRequestParams(uri=uri_param),
@@ -1241,12 +1242,12 @@ class FastMCP(Generic[LifespanResultT]):
         async with fastmcp.server.context.Context(fastmcp=self):
             try:
                 return await self._get_prompt_middleware(name, arguments)
-            except DisabledError:
+            except DisabledError as e:
                 # convert to NotFoundError to avoid leaking prompt presence
-                raise NotFoundError(f"Unknown prompt: {name}")
-            except NotFoundError:
+                raise NotFoundError(f"Unknown prompt: {name}") from e
+            except NotFoundError as e:
                 # standardize NotFound message
-                raise NotFoundError(f"Unknown prompt: {name}")
+                raise NotFoundError(f"Unknown prompt: {name}") from e
 
     async def _get_prompt_middleware(
         self, name: str, arguments: dict[str, Any] | None = None
@@ -1369,7 +1370,7 @@ class FastMCP(Generic[LifespanResultT]):
         description: str | None = None,
         icons: list[mcp.types.Icon] | None = None,
         tags: set[str] | None = None,
-        output_schema: dict[str, Any] | None | NotSetT = NotSet,
+        output_schema: dict[str, Any] | NotSetT | None = NotSet,
         annotations: ToolAnnotations | dict[str, Any] | None = None,
         exclude_args: list[str] | None = None,
         meta: dict[str, Any] | None = None,
@@ -1386,7 +1387,7 @@ class FastMCP(Generic[LifespanResultT]):
         description: str | None = None,
         icons: list[mcp.types.Icon] | None = None,
         tags: set[str] | None = None,
-        output_schema: dict[str, Any] | None | NotSetT = NotSet,
+        output_schema: dict[str, Any] | NotSetT | None = NotSet,
         annotations: ToolAnnotations | dict[str, Any] | None = None,
         exclude_args: list[str] | None = None,
         meta: dict[str, Any] | None = None,
@@ -1402,7 +1403,7 @@ class FastMCP(Generic[LifespanResultT]):
         description: str | None = None,
         icons: list[mcp.types.Icon] | None = None,
         tags: set[str] | None = None,
-        output_schema: dict[str, Any] | None | NotSetT = NotSet,
+        output_schema: dict[str, Any] | NotSetT | None = NotSet,
         annotations: ToolAnnotations | dict[str, Any] | None = None,
         exclude_args: list[str] | None = None,
         meta: dict[str, Any] | None = None,
@@ -2029,14 +2030,14 @@ class FastMCP(Generic[LifespanResultT]):
                 port=port,
                 path=server_path,
             )
-        _uvicorn_config_from_user = uvicorn_config or {}
+        uvicorn_config_from_user = uvicorn_config or {}
 
         config_kwargs: dict[str, Any] = {
             "timeout_graceful_shutdown": 0,
             "lifespan": "on",
             "ws": "websockets-sansio",
         }
-        config_kwargs.update(_uvicorn_config_from_user)
+        config_kwargs.update(uvicorn_config_from_user)
 
         if "log_config" not in config_kwargs and "log_level" not in config_kwargs:
             config_kwargs["log_level"] = default_log_level_to_use
@@ -2605,8 +2606,8 @@ class FastMCP(Generic[LifespanResultT]):
             # - Connected clients: reuse existing session for all requests
             # - Disconnected clients: create fresh sessions per request for isolation
             if client.is_connected():
-                _proxy_logger = get_logger(__name__)
-                _proxy_logger.info(
+                proxy_logger = get_logger(__name__)
+                proxy_logger.info(
                     "Proxy detected connected client - reusing existing session for all requests. "
                     "This may cause context mixing in concurrent scenarios."
                 )
@@ -2678,10 +2679,7 @@ class FastMCP(Generic[LifespanResultT]):
                 return False
 
         if self.include_tags is not None:
-            if any(itag in component.tags for itag in self.include_tags):
-                return True
-            else:
-                return False
+            return bool(any(itag in component.tags for itag in self.include_tags))
 
         return True
 

fastmcp/tools/__init__.py

@@ -2,4 +2,4 @@ from .tool import Tool, FunctionTool
 from .tool_manager import ToolManager
 from .tool_transform import forward, forward_raw
 
-__all__ = ["Tool", "ToolManager", "FunctionTool", "forward", "forward_raw"]
+__all__ = ["FunctionTool", "Tool", "ToolManager", "forward", "forward_raw"]

fastmcp/tools/tool.py

@@ -173,7 +173,7 @@ class Tool(FastMCPComponent):
         tags: set[str] | None = None,
         annotations: ToolAnnotations | None = None,
         exclude_args: list[str] | None = None,
-        output_schema: dict[str, Any] | None | NotSetT | Literal[False] = NotSet,
+        output_schema: dict[str, Any] | Literal[False] | NotSetT | None = NotSet,
         serializer: ToolResultSerializerType | None = None,
         meta: dict[str, Any] | None = None,
         enabled: bool | None = None,
@@ -212,13 +212,13 @@ class Tool(FastMCPComponent):
         tool: Tool,
         *,
         name: str | None = None,
-        title: str | None | NotSetT = NotSet,
-        description: str | None | NotSetT = NotSet,
+        title: str | NotSetT | None = NotSet,
+        description: str | NotSetT | None = NotSet,
         tags: set[str] | None = None,
-        annotations: ToolAnnotations | None | NotSetT = NotSet,
-        output_schema: dict[str, Any] | None | NotSetT | Literal[False] = NotSet,
+        annotations: ToolAnnotations | NotSetT | None = NotSet,
+        output_schema: dict[str, Any] | Literal[False] | NotSetT | None = NotSet,
         serializer: ToolResultSerializerType | None = None,
-        meta: dict[str, Any] | None | NotSetT = NotSet,
+        meta: dict[str, Any] | NotSetT | None = NotSet,
         transform_args: dict[str, ArgTransform] | None = None,
         enabled: bool | None = None,
         transform_fn: Callable[..., Any] | None = None,
@@ -255,7 +255,7 @@ class FunctionTool(Tool):
         tags: set[str] | None = None,
         annotations: ToolAnnotations | None = None,
         exclude_args: list[str] | None = None,
-        output_schema: dict[str, Any] | None | NotSetT | Literal[False] = NotSet,
+        output_schema: dict[str, Any] | Literal[False] | NotSetT | None = NotSet,
         serializer: ToolResultSerializerType | None = None,
         meta: dict[str, Any] | None = None,
         enabled: bool | None = None,
@@ -446,9 +446,8 @@ class ParsedFunction:
             # we ensure that no output schema is automatically generated.
             clean_output_type = replace_type(
                 output_type,
-                {
-                    t: _UnserializableType
-                    for t in (
+                dict.fromkeys(  # type: ignore[arg-type]
+                    (
                         Image,
                         Audio,
                         File,
@@ -458,8 +457,9 @@ class ParsedFunction:
                         mcp.types.AudioContent,
                         mcp.types.ResourceLink,
                         mcp.types.EmbeddedResource,
-                    )
-                },
+                    ),
+                    _UnserializableType,
+                ),
             )
 
             try:

fastmcp/tools/tool_transform.py

@@ -365,15 +365,15 @@ class TransformedTool(Tool):
         cls,
         tool: Tool,
         name: str | None = None,
-        title: str | None | NotSetT = NotSet,
-        description: str | None | NotSetT = NotSet,
+        title: str | NotSetT | None = NotSet,
+        description: str | NotSetT | None = NotSet,
         tags: set[str] | None = None,
         transform_fn: Callable[..., Any] | None = None,
         transform_args: dict[str, ArgTransform] | None = None,
-        annotations: ToolAnnotations | None | NotSetT = NotSet,
-        output_schema: dict[str, Any] | None | NotSetT | Literal[False] = NotSet,
-        serializer: Callable[[Any], str] | None | NotSetT = NotSet,
-        meta: dict[str, Any] | None | NotSetT = NotSet,
+        annotations: ToolAnnotations | NotSetT | None = NotSet,
+        output_schema: dict[str, Any] | Literal[False] | NotSetT | None = NotSet,
+        serializer: Callable[[Any], str] | NotSetT | None = NotSet,
+        meta: dict[str, Any] | NotSetT | None = NotSet,
         enabled: bool | None = None,
     ) -> TransformedTool:
         """Create a transformed tool from a parent tool.

fastmcp/utilities/cli.py

@@ -240,12 +240,11 @@ def log_server_banner(
     info_table.add_row("📦", "Transport:", display_transport)
 
     # Show connection info based on transport
-    if transport in ("http", "streamable-http", "sse"):
-        if host and port:
-            server_url = f"http://{host}:{port}"
-            if path:
-                server_url += f"/{path.lstrip('/')}"
-            info_table.add_row("🔗", "Server URL:", server_url)
+    if transport in ("http", "streamable-http", "sse") and host and port:
+        server_url = f"http://{host}:{port}"
+        if path:
+            server_url += f"/{path.lstrip('/')}"
+        info_table.add_row("🔗", "Server URL:", server_url)
 
     # Add documentation link
     info_table.add_row("", "", "")

fastmcp/utilities/inspect.py

@@ -412,7 +412,7 @@ class InspectFormat(str, Enum):
     MCP = "mcp"
 
 
-async def format_fastmcp_info(info: FastMCPInfo) -> bytes:
+def format_fastmcp_info(info: FastMCPInfo) -> bytes:
     """Format FastMCPInfo as FastMCP-specific JSON.
 
     This includes FastMCP-specific fields like tags, enabled, annotations, etc.
@@ -501,6 +501,6 @@ async def format_info(
         # This works for both v1 and v2 servers
         if info is None:
             info = await inspect_fastmcp(mcp)
-        return await format_fastmcp_info(info)
+        return format_fastmcp_info(info)
     else:
         raise ValueError(f"Unknown format: {format}")

fastmcp/utilities/json_schema_type.py

@@ -61,7 +61,7 @@ from pydantic import (
 )
 from typing_extensions import NotRequired, TypedDict
 
-__all__ = ["json_schema_to_type", "JSONSchema"]
+__all__ = ["JSONSchema", "json_schema_to_type"]
 
 
 FORMAT_TYPES: dict[str, Any] = {
@@ -368,7 +368,7 @@ def _schema_to_type(
                 return types[0]
         else:
             if has_null:
-                return Union[tuple(types + [type(None)])]  # type: ignore # noqa: UP007
+                return Union[(*types, type(None))]  # type: ignore
             else:
                 return Union[tuple(types)]  # type: ignore # noqa: UP007
 
@@ -389,7 +389,7 @@ def _schema_to_type(
             if len(types) == 1:
                 return types[0] | None  # type: ignore
             else:
-                return Union[tuple(types + [type(None)])]  # type: ignore # noqa: UP007
+                return Union[(*types, type(None))]  # type: ignore
         return Union[tuple(types)]  # type: ignore # noqa: UP007
 
     return _get_from_type_handler(schema, schemas)(schema)
@@ -578,7 +578,7 @@ def _create_dataclass(
             return _merge_defaults(data, original_schema)
         return data
 
-    setattr(cls, "_apply_defaults", _apply_defaults)
+    cls._apply_defaults = _apply_defaults  # type: ignore[attr-defined]
 
     # Store completed class
     _classes[cache_key] = cls

fastmcp/utilities/logging.py

@@ -147,6 +147,18 @@ def temporary_log_level(
         yield
 
 
+_level_to_no: dict[
+    Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None, int | None
+] = {
+    "DEBUG": logging.DEBUG,
+    "INFO": logging.INFO,
+    "WARNING": logging.WARNING,
+    "ERROR": logging.ERROR,
+    "CRITICAL": logging.CRITICAL,
+    None: None,
+}
+
+
 class _ClampedLogFilter(logging.Filter):
     min_level: tuple[int, str] | None
     max_level: tuple[int, str] | None
@@ -161,29 +173,13 @@ class _ClampedLogFilter(logging.Filter):
         self.min_level = None
         self.max_level = None
 
-        if min_level_no := self._level_to_no(level=min_level):
+        if min_level_no := _level_to_no.get(min_level):
             self.min_level = (min_level_no, str(min_level))
-        if max_level_no := self._level_to_no(level=max_level):
+        if max_level_no := _level_to_no.get(max_level):
             self.max_level = (max_level_no, str(max_level))
 
         super().__init__()
 
-    def _level_to_no(
-        self, level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None
-    ) -> int | None:
-        if level == "DEBUG":
-            return logging.DEBUG
-        elif level == "INFO":
-            return logging.INFO
-        elif level == "WARNING":
-            return logging.WARNING
-        elif level == "ERROR":
-            return logging.ERROR
-        elif level == "CRITICAL":
-            return logging.CRITICAL
-        else:
-            return None
-
     @override
     def filter(self, record: logging.LogRecord) -> bool:
         if self.max_level:

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/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 (

fastmcp/utilities/tests.py

@@ -6,7 +6,7 @@ import multiprocessing
 import socket
 import time
 from collections.abc import AsyncGenerator, Callable, Generator
-from contextlib import asynccontextmanager, contextmanager
+from contextlib import asynccontextmanager, contextmanager, suppress
 from typing import TYPE_CHECKING, Any, Literal
 from urllib.parse import parse_qs, urlparse
 
@@ -216,10 +216,8 @@ async def run_server_async(
     finally:
         # Cleanup: cancel the task
         server_task.cancel()
-        try:
+        with suppress(asyncio.CancelledError):
             await server_task
-        except asyncio.CancelledError:
-            pass
 
 
 @contextmanager

{fastmcp-2.13.0rc3.dist-info → fastmcp-2.13.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.13.0rc3
+Version: 2.13.0.2
 Summary: The fast, Pythonic way to build MCP servers and clients.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -22,11 +22,11 @@ Requires-Dist: authlib>=1.5.2
 Requires-Dist: cyclopts>=3.0.0
 Requires-Dist: exceptiongroup>=1.2.2
 Requires-Dist: httpx>=0.28.1
+Requires-Dist: jsonschema-path>=0.3.4
 Requires-Dist: mcp<2.0.0,>=1.17.0
-Requires-Dist: openapi-core>=0.19.5
 Requires-Dist: openapi-pydantic>=0.5.1
 Requires-Dist: platformdirs>=4.0.0
-Requires-Dist: py-key-value-aio[disk,keyring,memory]<0.3.0,>=0.2.6
+Requires-Dist: py-key-value-aio[disk,keyring,memory]<0.3.0,>=0.2.8
 Requires-Dist: pydantic[email]>=2.11.7
 Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: python-dotenv>=1.1.0