fastmcp 2.11.1__py3-none-any.whl → 2.11.3__py3-none-any.whl

fastmcp/server/proxy.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+import inspect
 import warnings
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 from urllib.parse import quote
@@ -48,11 +49,27 @@ if TYPE_CHECKING:
 
 logger = get_logger(__name__)
 
+# Type alias for client factory functions
+ClientFactoryT = Callable[[], Client] | Callable[[], Awaitable[Client]]
 
-class ProxyToolManager(ToolManager):
+
+class ProxyManagerMixin:
+    """A mixin for proxy managers to provide a unified client retrieval method."""
+
+    client_factory: ClientFactoryT
+
+    async def _get_client(self) -> Client:
+        """Gets a client instance by calling the sync or async factory."""
+        client = self.client_factory()
+        if inspect.isawaitable(client):
+            client = await client
+        return client
+
+
+class ProxyToolManager(ToolManager, ProxyManagerMixin):
     """A ToolManager that sources its tools from a remote client in addition to local and mounted tools."""
 
-    def __init__(self, client_factory: Callable[[], Client], **kwargs):
+    def __init__(self, client_factory: ClientFactoryT, **kwargs):
         super().__init__(**kwargs)
         self.client_factory = client_factory
 
@@ -63,7 +80,7 @@ class ProxyToolManager(ToolManager):
 
         # Then add proxy tools, but don't overwrite existing ones
         try:
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 client_tools = await client.list_tools()
                 for tool in client_tools:
@@ -94,7 +111,7 @@ class ProxyToolManager(ToolManager):
             return await super().call_tool(key, arguments)
         except NotFoundError:
             # If not found locally, try proxy
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 result = await client.call_tool(key, arguments)
                 return ToolResult(
@@ -103,10 +120,10 @@ class ProxyToolManager(ToolManager):
                 )
 
 
-class ProxyResourceManager(ResourceManager):
+class ProxyResourceManager(ResourceManager, ProxyManagerMixin):
     """A ResourceManager that sources its resources from a remote client in addition to local and mounted resources."""
 
-    def __init__(self, client_factory: Callable[[], Client], **kwargs):
+    def __init__(self, client_factory: ClientFactoryT, **kwargs):
         super().__init__(**kwargs)
         self.client_factory = client_factory
 
@@ -117,7 +134,7 @@ class ProxyResourceManager(ResourceManager):
 
         # Then add proxy resources, but don't overwrite existing ones
         try:
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 client_resources = await client.list_resources()
                 for resource in client_resources:
@@ -140,7 +157,7 @@ class ProxyResourceManager(ResourceManager):
 
         # Then add proxy templates, but don't overwrite existing ones
         try:
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 client_templates = await client.list_resource_templates()
                 for template in client_templates:
@@ -173,7 +190,7 @@ class ProxyResourceManager(ResourceManager):
             return await super().read_resource(uri)
         except NotFoundError:
             # If not found locally, try proxy
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 result = await client.read_resource(uri)
                 if isinstance(result[0], TextResourceContents):
@@ -184,10 +201,10 @@ class ProxyResourceManager(ResourceManager):
                     raise ResourceError(f"Unsupported content type: {type(result[0])}")
 
 
-class ProxyPromptManager(PromptManager):
+class ProxyPromptManager(PromptManager, ProxyManagerMixin):
     """A PromptManager that sources its prompts from a remote client in addition to local and mounted prompts."""
 
-    def __init__(self, client_factory: Callable[[], Client], **kwargs):
+    def __init__(self, client_factory: ClientFactoryT, **kwargs):
         super().__init__(**kwargs)
         self.client_factory = client_factory
 
@@ -198,7 +215,7 @@ class ProxyPromptManager(PromptManager):
 
         # Then add proxy prompts, but don't overwrite existing ones
         try:
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 client_prompts = await client.list_prompts()
                 for prompt in client_prompts:
@@ -230,7 +247,7 @@ class ProxyPromptManager(PromptManager):
             return await super().render_prompt(name, arguments)
         except NotFoundError:
             # If not found locally, try proxy
-            client = self.client_factory()
+            client = await self._get_client()
             async with client:
                 result = await client.get_prompt(name, arguments)
                 return result
@@ -444,7 +461,7 @@ class FastMCPProxy(FastMCP):
         self,
         client: Client | None = None,
         *,
-        client_factory: Callable[[], Client] | None = None,
+        client_factory: ClientFactoryT | None = None,
         **kwargs,
     ):
         """
@@ -459,6 +476,7 @@ class FastMCPProxy(FastMCP):
                    created that provides session isolation for backwards compatibility.
             client_factory: A callable that returns a Client instance when called.
                            This gives you full control over session creation and reuse.
+                           Can be either a synchronous or asynchronous function.
             **kwargs: Additional settings for the FastMCP server.
         """
 

fastmcp/server/server.py

@@ -49,7 +49,7 @@ from fastmcp.prompts import Prompt, PromptManager
 from fastmcp.prompts.prompt import FunctionPrompt
 from fastmcp.resources import Resource, ResourceManager
 from fastmcp.resources.template import ResourceTemplate
-from fastmcp.server.auth.auth import AuthProvider
+from fastmcp.server.auth import AuthProvider
 from fastmcp.server.auth.registry import get_registered_provider
 from fastmcp.server.http import (
     StarletteWithLifespan,
@@ -140,19 +140,18 @@ class FastMCP(Generic[LifespanResultT]):
             ]
             | None
         ) = None,
-        tool_serializer: Callable[[Any], str] | None = None,
-        cache_expiration_seconds: float | None = None,
-        on_duplicate_tools: DuplicateBehavior | None = None,
-        on_duplicate_resources: DuplicateBehavior | None = None,
-        on_duplicate_prompts: DuplicateBehavior | None = None,
+        dependencies: list[str] | None = None,
         resource_prefix_format: Literal["protocol", "path"] | None = None,
         mask_error_details: bool | None = None,
         tools: list[Tool | Callable[..., Any]] | None = None,
         tool_transformations: dict[str, ToolTransformConfig] | None = None,
-        dependencies: list[str] | None = None,
+        tool_serializer: Callable[[Any], str] | None = None,
         include_tags: set[str] | None = None,
         exclude_tags: set[str] | None = None,
         include_fastmcp_meta: bool | None = None,
+        on_duplicate_tools: DuplicateBehavior | None = None,
+        on_duplicate_resources: DuplicateBehavior | None = None,
+        on_duplicate_prompts: DuplicateBehavior | None = None,
         # ---
         # ---
         # --- The following arguments are DEPRECATED ---
@@ -304,6 +303,10 @@ class FastMCP(Generic[LifespanResultT]):
     def instructions(self) -> str | None:
         return self._mcp_server.instructions
 
+    @property
+    def version(self) -> str | None:
+        return self._mcp_server.version
+
     async def run_async(
         self,
         transport: Transport | None = None,
@@ -1888,7 +1891,7 @@ class FastMCP(Generic[LifespanResultT]):
         # Import tools from the server
         for key, tool in (await server.get_tools()).items():
             if prefix:
-                tool = tool.with_key(f"{prefix}_{key}")
+                tool = tool.model_copy(key=f"{prefix}_{key}")
             self._tool_manager.add_tool(tool)
 
         # Import resources and templates from the server
@@ -1897,7 +1900,9 @@ class FastMCP(Generic[LifespanResultT]):
                 resource_key = add_resource_prefix(
                     key, prefix, self.resource_prefix_format
                 )
-                resource = resource.with_key(resource_key)
+                resource = resource.model_copy(
+                    update={"name": f"{prefix}_{resource.name}"}, key=resource_key
+                )
             self._resource_manager.add_resource(resource)
 
         for key, template in (await server.get_resource_templates()).items():
@@ -1905,13 +1910,15 @@ class FastMCP(Generic[LifespanResultT]):
                 template_key = add_resource_prefix(
                     key, prefix, self.resource_prefix_format
                 )
-                template = template.with_key(template_key)
+                template = template.model_copy(
+                    update={"name": f"{prefix}_{template.name}"}, key=template_key
+                )
             self._resource_manager.add_template(template)
 
         # Import prompts from the server
         for key, prompt in (await server.get_prompts()).items():
             if prefix:
-                prompt = prompt.with_key(f"{prefix}_{key}")
+                prompt = prompt.model_copy(key=f"{prefix}_{key}")
             self._prompt_manager.add_prompt(prompt)
 
         if prefix:

fastmcp/settings.py

@@ -222,9 +222,9 @@ class Settings(BaseSettings):
     # HTTP settings
     host: str = "127.0.0.1"
     port: int = 8000
-    sse_path: str = "/sse/"
+    sse_path: str = "/sse"
     message_path: str = "/messages/"
-    streamable_http_path: str = "/mcp/"
+    streamable_http_path: str = "/mcp"
     debug: bool = False
 
     # error handling
@@ -244,13 +244,10 @@ class Settings(BaseSettings):
         ),
     ] = False
 
-    server_dependencies: Annotated[
-        list[str],
-        Field(
-            default_factory=list,
-            description="List of dependencies to install in the server environment",
-        ),
-    ] = []
+    server_dependencies: list[str] = Field(
+        default_factory=list,
+        description="List of dependencies to install in the server environment",
+    )
 
     # StreamableHTTP settings
     json_response: bool = False

fastmcp/tools/tool.py

@@ -8,7 +8,6 @@ from typing import (
     Annotated,
     Any,
     Generic,
-    Literal,
     TypeVar,
     get_type_hints,
 )
@@ -163,7 +162,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] | None | NotSetT = NotSet,
         serializer: Callable[[Any], str] | None = None,
         meta: dict[str, Any] | None = None,
         enabled: bool | None = None,
@@ -199,17 +198,18 @@ class Tool(FastMCPComponent):
     def from_tool(
         cls,
         tool: Tool,
-        transform_fn: Callable[..., Any] | None = None,
+        *,
         name: str | None = None,
         title: str | None | NotSetT = NotSet,
-        transform_args: dict[str, ArgTransform] | None = None,
         description: str | None | NotSetT = NotSet,
         tags: set[str] | None = None,
-        annotations: ToolAnnotations | None = None,
-        output_schema: dict[str, Any] | None | Literal[False] = None,
+        annotations: ToolAnnotations | None | NotSetT = NotSet,
+        output_schema: dict[str, Any] | None | NotSetT = NotSet,
         serializer: Callable[[Any], str] | None = None,
         meta: dict[str, Any] | None | NotSetT = NotSet,
+        transform_args: dict[str, ArgTransform] | None = None,
         enabled: bool | None = None,
+        transform_fn: Callable[..., Any] | None = None,
     ) -> TransformedTool:
         from fastmcp.tools.tool_transform import TransformedTool
 
@@ -242,7 +242,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] | None | NotSetT = NotSet,
         serializer: Callable[[Any], str] | None = None,
         meta: dict[str, Any] | None = None,
         enabled: bool | None = None,

fastmcp/tools/tool_manager.py

@@ -75,7 +75,9 @@ class ToolManager:
                 child_dict = {t.key: t for t in child_results}
                 if mounted.prefix:
                     for tool in child_dict.values():
-                        prefixed_tool = tool.with_key(f"{mounted.prefix}_{tool.key}")
+                        prefixed_tool = tool.model_copy(
+                            key=f"{mounted.prefix}_{tool.key}"
+                        )
                         all_tools[prefixed_tool.key] = prefixed_tool
                 else:
                     all_tools.update(child_dict)

fastmcp/tools/tool_transform.py

@@ -6,6 +6,7 @@ from contextvars import ContextVar
 from dataclasses import dataclass
 from typing import Annotated, Any, Literal
 
+import pydantic_core
 from mcp.types import ToolAnnotations
 from pydantic import ConfigDict
 from pydantic.fields import Field
@@ -312,11 +313,9 @@ class TransformedTool(Tool):
                         # Custom function returns ToolResult - preserve its content
                         return result
                     else:
-                        # Forwarded call with disabled schema - strip structured content
-                        return ToolResult(
-                            content=result.content,
-                            structured_content=None,
-                        )
+                        # Forwarded call with no explicit schema - preserve parent's structured content
+                        # The parent tool may have generated structured content via its own fallback logic
+                        return result
                 elif self.output_schema.get(
                     "type"
                 ) != "object" and not self.output_schema.get("x-fastmcp-wrap-result"):
@@ -334,17 +333,23 @@ class TransformedTool(Tool):
                 result, serializer=self.serializer
             )
 
-            # Handle structured content based on output schema
+            structured_output = None
+            # First handle structured content based on output schema, if any
             if self.output_schema is not None:
                 if self.output_schema.get("x-fastmcp-wrap-result"):
                     # Schema says wrap - always wrap in result key
                     structured_output = {"result": result}
                 else:
-                    # Object schemas - use result directly
-                    # User is responsible for returning dict-compatible data
                     structured_output = result
-            else:
-                structured_output = None
+            # If no output schema, try to serialize the result. If it is a dict, use
+            # it as structured content. If it is not a dict, ignore it.
+            if structured_output is None:
+                try:
+                    structured_output = pydantic_core.to_jsonable_python(result)
+                    if not isinstance(structured_output, dict):
+                        structured_output = None
+                except Exception:
+                    pass
 
             return ToolResult(
                 content=unstructured_result,
@@ -363,9 +368,9 @@ class TransformedTool(Tool):
         tags: set[str] | None = None,
         transform_fn: Callable[..., Any] | None = None,
         transform_args: dict[str, ArgTransform] | None = None,
-        annotations: ToolAnnotations | None = None,
-        output_schema: dict[str, Any] | None | Literal[False] = None,
-        serializer: Callable[[Any], str] | None = None,
+        annotations: ToolAnnotations | None | NotSetT = NotSet,
+        output_schema: dict[str, Any] | None | NotSetT = NotSet,
+        serializer: Callable[[Any], str] | None | NotSetT = NotSet,
         meta: dict[str, Any] | None | NotSetT = NotSet,
         enabled: bool | None = None,
     ) -> TransformedTool:
@@ -445,6 +450,11 @@ class TransformedTool(Tool):
         """
         transform_args = transform_args or {}
 
+        if transform_fn is not None:
+            parsed_fn = ParsedFunction.from_function(transform_fn, validate=False)
+        else:
+            parsed_fn = None
+
         # Validate transform_args
         parent_params = set(tool.parameters.get("properties", {}).keys())
         unknown_args = set(transform_args.keys()) - parent_params
@@ -457,16 +467,11 @@ class TransformedTool(Tool):
         # Always create the forwarding transform
         schema, forwarding_fn = cls._create_forwarding_transform(tool, transform_args)
 
-        # Handle output schema with smart fallback
-        if output_schema is False:
-            final_output_schema = None
-        elif output_schema is not None:
-            # Explicit schema provided - use as-is
-            final_output_schema = output_schema
-        else:
-            # Smart fallback: try custom function, then parent, then None
+        # Handle output schema
+        if output_schema is NotSet:
+            # Use smart fallback: try custom function, then parent
             if transform_fn is not None:
-                parsed_fn = ParsedFunction.from_function(transform_fn, validate=False)
+                assert parsed_fn is not None
                 final_output_schema = parsed_fn.output_schema
                 if final_output_schema is None:
                     # Check if function returns ToolResult - if so, don't fall back to parent
@@ -479,15 +484,17 @@ class TransformedTool(Tool):
                         final_output_schema = tool.output_schema
             else:
                 final_output_schema = tool.output_schema
+        else:
+            assert isinstance(output_schema, dict | None)
+            final_output_schema = output_schema
 
         if transform_fn is None:
             # User wants pure transformation - use forwarding_fn as the main function
             final_fn = forwarding_fn
             final_schema = schema
         else:
+            assert parsed_fn is not None
             # User provided custom function - merge schemas
-            if "parsed_fn" not in locals():
-                parsed_fn = ParsedFunction.from_function(transform_fn, validate=False)
             final_fn = transform_fn
 
             has_kwargs = cls._function_has_kwargs(transform_fn)
@@ -552,6 +559,13 @@ class TransformedTool(Tool):
         )
         final_title = title if not isinstance(title, NotSetT) else tool.title
         final_meta = meta if not isinstance(meta, NotSetT) else tool.meta
+        final_annotations = (
+            annotations if not isinstance(annotations, NotSetT) else tool.annotations
+        )
+        final_serializer = (
+            serializer if not isinstance(serializer, NotSetT) else tool.serializer
+        )
+        final_enabled = enabled if enabled is not None else tool.enabled
 
         transformed_tool = cls(
             fn=final_fn,
@@ -563,11 +577,11 @@ class TransformedTool(Tool):
             parameters=final_schema,
             output_schema=final_output_schema,
             tags=tags or tool.tags,
-            annotations=annotations or tool.annotations,
-            serializer=serializer or tool.serializer,
+            annotations=final_annotations,
+            serializer=final_serializer,
             meta=final_meta,
             transform_args=transform_args,
-            enabled=enabled if enabled is not None else True,
+            enabled=final_enabled,
         )
 
         return transformed_tool

fastmcp/utilities/components.py

@@ -91,12 +91,27 @@ class FastMCPComponent(FastMCPBaseModel):
 
         return meta or None
 
-    def with_key(self, key: str) -> Self:
+    def model_copy(
+        self,
+        *,
+        update: dict[str, Any] | None = None,
+        deep: bool = False,
+        key: str | None = None,
+    ) -> Self:
+        """
+        Create a copy of the component.
+
+        Args:
+            update: A dictionary of fields to update.
+            deep: Whether to deep copy the component.
+            key: The key to use for the copy.
+        """
         # `model_copy` has an `update` parameter but it doesn't work for certain private attributes
         # https://github.com/pydantic/pydantic/issues/12116
-        # So we manually set the private attribute here instead
-        copy = self.model_copy()
-        copy._key = key
+        # So we manually set the private attribute here instead, such as _key
+        copy = super().model_copy(update=update, deep=deep)
+        if key is not None:
+            copy._key = key
         return copy
 
     def __eq__(self, other: object) -> bool:

fastmcp/utilities/inspect.py

@@ -9,6 +9,7 @@ from typing import Any
 from mcp.server.fastmcp import FastMCP as FastMCP1x
 
 import fastmcp
+from fastmcp import Client
 from fastmcp.server.server import FastMCP
 
 
@@ -71,7 +72,7 @@ class FastMCPInfo:
     instructions: str | None
     fastmcp_version: str
     mcp_version: str
-    server_version: str
+    server_version: str | None
     tools: list[ToolInfo]
     prompts: list[PromptInfo]
     resources: list[ResourceInfo]
@@ -170,7 +171,9 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
         instructions=mcp.instructions,
         fastmcp_version=fastmcp.__version__,
         mcp_version=importlib.metadata.version("mcp"),
-        server_version=fastmcp.__version__,  # v2.x uses FastMCP version
+        server_version=(
+            mcp.version if hasattr(mcp, "version") else mcp._mcp_server.version
+        ),
         tools=tool_infos,
         prompts=prompt_infos,
         resources=resource_infos,
@@ -179,7 +182,7 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
     )
 
 
-async def inspect_fastmcp_v1(mcp: Any) -> FastMCPInfo:
+async def inspect_fastmcp_v1(mcp: FastMCP1x) -> FastMCPInfo:
     """Extract information from a FastMCP v1.x instance using a Client.
 
     Args:
@@ -188,7 +191,6 @@ async def inspect_fastmcp_v1(mcp: Any) -> FastMCPInfo:
     Returns:
         FastMCPInfo dataclass containing the extracted information
     """
-    from fastmcp import Client
 
     # Use a client to interact with the FastMCP1x server
     async with Client(mcp) as client:
@@ -288,11 +290,11 @@ async def inspect_fastmcp_v1(mcp: Any) -> FastMCPInfo:
         }
 
         return FastMCPInfo(
-            name=mcp.name,
-            instructions=getattr(mcp, "instructions", None),
-            fastmcp_version=fastmcp.__version__,  # Report current fastmcp version
+            name=mcp._mcp_server.name,
+            instructions=mcp._mcp_server.instructions,
+            fastmcp_version=importlib.metadata.version("mcp"),
             mcp_version=importlib.metadata.version("mcp"),
-            server_version="1.0",  # FastMCP 1.x version
+            server_version=mcp._mcp_server.version,
             tools=tool_infos,
             prompts=prompt_infos,
             resources=resource_infos,
@@ -301,14 +303,7 @@ async def inspect_fastmcp_v1(mcp: Any) -> FastMCPInfo:
         )
 
 
-def _is_fastmcp_v1(mcp: Any) -> bool:
-    """Check if the given instance is a FastMCP v1.x instance."""
-
-    # Check if it's an instance of FastMCP1x and not FastMCP2
-    return isinstance(mcp, FastMCP1x) and not isinstance(mcp, FastMCP)
-
-
-async def inspect_fastmcp(mcp: FastMCP[Any] | Any) -> FastMCPInfo:
+async def inspect_fastmcp(mcp: FastMCP[Any] | FastMCP1x) -> FastMCPInfo:
     """Extract information from a FastMCP instance into a dataclass.
 
     This function automatically detects whether the instance is FastMCP v1.x or v2.x
@@ -320,7 +315,7 @@ async def inspect_fastmcp(mcp: FastMCP[Any] | Any) -> FastMCPInfo:
     Returns:
         FastMCPInfo dataclass containing the extracted information
     """
-    if _is_fastmcp_v1(mcp):
+    if isinstance(mcp, FastMCP1x):
         return await inspect_fastmcp_v1(mcp)
     else:
         return await inspect_fastmcp_v2(mcp)

fastmcp/utilities/openapi.py

@@ -212,7 +212,7 @@ def parse_openapi_to_http_routes(openapi_dict: dict[str, Any]) -> list[HTTPRoute
         if openapi_version.startswith("3.0"):
             # Use OpenAPI 3.0 models
             openapi_30 = OpenAPI_30.model_validate(openapi_dict)
-            logger.info(
+            logger.debug(
                 f"Successfully parsed OpenAPI 3.0 schema version: {openapi_30.openapi}"
             )
             parser = OpenAPIParser(
@@ -230,7 +230,7 @@ def parse_openapi_to_http_routes(openapi_dict: dict[str, Any]) -> list[HTTPRoute
         else:
             # Default to OpenAPI 3.1 models
             openapi_31 = OpenAPI.model_validate(openapi_dict)
-            logger.info(
+            logger.debug(
                 f"Successfully parsed OpenAPI 3.1 schema version: {openapi_31.openapi}"
             )
             parser = OpenAPIParser(
@@ -713,7 +713,7 @@ class OpenAPIParser(
                             openapi_version=self.openapi_version,
                         )
                         routes.append(route)
-                        logger.info(
+                        logger.debug(
                             f"Successfully extracted route: {method_upper} {path_str}"
                         )
                     except ValueError as op_error:
@@ -734,7 +734,7 @@ class OpenAPIParser(
                             exc_info=True,
                         )
 
-        logger.info(f"Finished parsing. Extracted {len(routes)} HTTP routes.")
+        logger.debug(f"Finished parsing. Extracted {len(routes)} HTTP routes.")
         return routes
 
 

{fastmcp-2.11.1.dist-info → fastmcp-2.11.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.11.1
+Version: 2.11.3
 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
@@ -21,7 +21,7 @@ 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: mcp>=1.10.0
+Requires-Dist: mcp<2.0.0,>=1.12.4
 Requires-Dist: openapi-core>=0.19.5
 Requires-Dist: openapi-pydantic>=0.5.1
 Requires-Dist: pydantic[email]>=2.11.7