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

fastmcp/cli/cli.py

@@ -138,7 +138,7 @@ def version(
 
 
 @app.command
-def dev(
+async def dev(
     server_spec: str,
     *,
     with_editable: Annotated[
@@ -220,7 +220,7 @@ def dev(
 
     try:
         # Import server to get dependencies
-        server: FastMCP = run_module.import_server(file, server_object)
+        server: FastMCP = await run_module.import_server(file, server_object)
         if server.dependencies is not None:
             with_packages = list(set(with_packages + server.dependencies))
 
@@ -283,7 +283,7 @@ def dev(
 
 
 @app.command
-def run(
+async def run(
     server_spec: str,
     *server_args: str,
     transport: Annotated[
@@ -414,7 +414,7 @@ def run(
     else:
         # Use direct import for backwards compatibility
         try:
-            run_module.run_command(
+            await run_module.run_command(
                 server_spec=server_spec,
                 transport=transport,
                 host=host,
@@ -476,7 +476,7 @@ async def inspect(
 
     try:
         # Import the server
-        server = run_module.import_server(file, server_object)
+        server = await run_module.import_server(file, server_object)
 
         # Get server information - using native async support
         info = await inspect_fastmcp(server)

fastmcp/cli/install/claude_code.py

@@ -167,7 +167,7 @@ def install_claude_code(
         return False
 
 
-def claude_code_command(
+async def claude_code_command(
     server_spec: str,
     *,
     server_name: Annotated[
@@ -234,7 +234,7 @@ def claude_code_command(
     Args:
         server_spec: Python file to install, optionally with :object suffix
     """
-    file, server_object, name, packages, env_dict = process_common_args(
+    file, server_object, name, packages, env_dict = await process_common_args(
         server_spec, server_name, with_packages, env_vars, env_file
     )
 

fastmcp/cli/install/claude_desktop.py

@@ -140,7 +140,7 @@ def install_claude_desktop(
         return False
 
 
-def claude_desktop_command(
+async def claude_desktop_command(
     server_spec: str,
     *,
     server_name: Annotated[
@@ -207,7 +207,7 @@ def claude_desktop_command(
     Args:
         server_spec: Python file to install, optionally with :object suffix
     """
-    file, server_object, name, with_packages, env_dict = process_common_args(
+    file, server_object, name, with_packages, env_dict = await process_common_args(
         server_spec, server_name, with_packages, env_vars, env_file
     )
 

fastmcp/cli/install/cursor.py

@@ -150,7 +150,7 @@ def install_cursor(
         return False
 
 
-def cursor_command(
+async def cursor_command(
     server_spec: str,
     *,
     server_name: Annotated[
@@ -217,7 +217,7 @@ def cursor_command(
     Args:
         server_spec: Python file to install, optionally with :object suffix
     """
-    file, server_object, name, with_packages, env_dict = process_common_args(
+    file, server_object, name, with_packages, env_dict = await process_common_args(
         server_spec, server_name, with_packages, env_vars, env_file
     )
 

fastmcp/cli/install/mcp_json.py

@@ -113,7 +113,7 @@ def install_mcp_json(
         return False
 
 
-def mcp_json_command(
+async def mcp_json_command(
     server_spec: str,
     *,
     server_name: Annotated[
@@ -188,7 +188,7 @@ def mcp_json_command(
     Args:
         server_spec: Python file to install, optionally with :object suffix
     """
-    file, server_object, name, packages, env_dict = process_common_args(
+    file, server_object, name, packages, env_dict = await process_common_args(
         server_spec, server_name, with_packages, env_vars, env_file
     )
 

fastmcp/cli/install/shared.py

@@ -23,7 +23,7 @@ def parse_env_var(env_var: str) -> tuple[str, str]:
     return key.strip(), value.strip()
 
 
-def process_common_args(
+async def process_common_args(
     server_spec: str,
     server_name: str | None,
     with_packages: list[str],
@@ -49,7 +49,7 @@ def process_common_args(
     server = None
     if not name:
         try:
-            server = import_server(file, server_object)
+            server = await import_server(file, server_object)
             name = server.name
         except (ImportError, ModuleNotFoundError) as e:
             logger.debug(

fastmcp/cli/run.py

@@ -1,6 +1,7 @@
 """FastMCP run command implementation with enhanced type hints."""
 
 import importlib.util
+import inspect
 import json
 import re
 import subprocess
@@ -58,15 +59,15 @@ def parse_file_path(server_spec: str) -> tuple[Path, str | None]:
     return file_path, server_object
 
 
-def import_server(file: Path, server_object: str | None = None) -> Any:
+async def import_server(file: Path, server_or_factory: str | None = None) -> Any:
     """Import a MCP server from a file.
 
     Args:
         file: Path to the file
-        server_object: Optional object name in format "module:object" or just "object"
+        server_or_factory: Optional object name in format "module:object" or just "object"
 
     Returns:
-        The server object
+        The server object (or result of calling a factory function)
     """
     # Add parent directory to Python path so imports can be resolved
     file_dir = str(file.parent)
@@ -86,11 +87,12 @@ def import_server(file: Path, server_object: str | None = None) -> Any:
     spec.loader.exec_module(module)
 
     # If no object specified, try common server names
-    if not server_object:
-        # Look for the most common server object names
+    if not server_or_factory:
+        # Look for common server instance names
         for name in ["mcp", "server", "app"]:
             if hasattr(module, name):
-                return getattr(module, name)
+                obj = getattr(module, name)
+                return await _resolve_server_or_factory(obj, file, name)
 
         logger.error(
             f"No server object found in {file}. Please either:\n"
@@ -100,14 +102,14 @@ def import_server(file: Path, server_object: str | None = None) -> Any:
         )
         sys.exit(1)
 
-    assert server_object is not None
+    assert server_or_factory is not None
 
     # Handle module:object syntax
-    if ":" in server_object:
-        module_name, object_name = server_object.split(":", 1)
+    if ":" in server_or_factory:
+        module_name, object_name = server_or_factory.split(":", 1)
         try:
             server_module = importlib.import_module(module_name)
-            server = getattr(server_module, object_name, None)
+            obj = getattr(server_module, object_name, None)
         except ImportError:
             logger.error(
                 f"Could not import module '{module_name}'",
@@ -116,16 +118,62 @@ def import_server(file: Path, server_object: str | None = None) -> Any:
             sys.exit(1)
     else:
         # Just object name
-        server = getattr(module, server_object, None)
+        obj = getattr(module, server_or_factory, None)
 
-    if server is None:
+    if obj is None:
         logger.error(
-            f"Server object '{server_object}' not found",
+            f"Server object '{server_or_factory}' not found",
             extra={"file": str(file)},
         )
         sys.exit(1)
 
-    return server
+    return await _resolve_server_or_factory(obj, file, server_or_factory)
+
+
+async def _resolve_server_or_factory(obj: Any, file: Path, name: str) -> Any:
+    """Resolve a server object or factory function to a server instance.
+
+    Args:
+        obj: The object that might be a server or factory function
+        file: Path to the file for error messages
+        name: Name of the object for error messages
+
+    Returns:
+        A server instance
+    """
+    # Check if it's a function or coroutine function
+    if inspect.isfunction(obj) or inspect.iscoroutinefunction(obj):
+        logger.debug(f"Found factory function '{name}' in {file}")
+
+        try:
+            if inspect.iscoroutinefunction(obj):
+                # Async factory function
+                server = await obj()
+            else:
+                # Sync factory function
+                server = obj()
+
+            # Validate the result is a FastMCP server
+            if not isinstance(server, FastMCP | FastMCP1x):
+                logger.error(
+                    f"Factory function '{name}' must return a FastMCP server instance, "
+                    f"got {type(server).__name__}",
+                    extra={"file": str(file)},
+                )
+                sys.exit(1)
+
+            logger.debug(f"Factory function '{name}' created server: {server.name}")
+            return server
+
+        except Exception as e:
+            logger.error(
+                f"Failed to call factory function '{name}': {e}",
+                extra={"file": str(file)},
+            )
+            sys.exit(1)
+
+    # Not a function, return as-is (should be a server instance)
+    return obj
 
 
 def run_with_uv(
@@ -219,7 +267,7 @@ def create_client_server(url: str) -> Any:
         import fastmcp
 
         client = fastmcp.Client(url)
-        server = fastmcp.FastMCP.from_client(client)
+        server = fastmcp.FastMCP.as_proxy(client)
         return server
     except Exception as e:
         logger.error(f"Failed to create client for URL {url}: {e}")
@@ -237,14 +285,16 @@ def create_mcp_config_server(mcp_config_path: Path) -> FastMCP[None]:
     return server
 
 
-def import_server_with_args(
-    file: Path, server_object: str | None = None, server_args: list[str] | None = None
+async def import_server_with_args(
+    file: Path,
+    server_or_factory: str | None = None,
+    server_args: list[str] | None = None,
 ) -> Any:
     """Import a server with optional command line arguments.
 
     Args:
         file: Path to the server file
-        server_object: Optional server object name
+        server_or_factory: Optional server object or factory function name
         server_args: Optional command line arguments to inject
 
     Returns:
@@ -254,14 +304,14 @@ def import_server_with_args(
         original_argv = sys.argv[:]
         try:
             sys.argv = [str(file)] + server_args
-            return import_server(file, server_object)
+            return await import_server(file, server_or_factory)
         finally:
             sys.argv = original_argv
     else:
-        return import_server(file, server_object)
+        return await import_server(file, server_or_factory)
 
 
-def run_command(
+async def run_command(
     server_spec: str,
     transport: TransportType | None = None,
     host: str | None = None,
@@ -293,8 +343,8 @@ def run_command(
         server = create_mcp_config_server(Path(server_spec))
     else:
         # Handle file case
-        file, server_object = parse_file_path(server_spec)
-        server = import_server_with_args(file, server_object, server_args)
+        file, server_or_factory = parse_file_path(server_spec)
+        server = await import_server_with_args(file, server_or_factory, server_args)
         logger.debug(f'Found server "{server.name}" in {file}')
 
     # Run the server
@@ -320,7 +370,7 @@ def run_command(
         kwargs["show_banner"] = False
 
     try:
-        server.run(**kwargs)
+        await server.run_async(**kwargs)
     except Exception as e:
         logger.error(f"Failed to run server: {e}")
         sys.exit(1)

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

@@ -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,

fastmcp/settings.py

@@ -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/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-2.11.1.dist-info → fastmcp-2.11.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.11.1
+Version: 2.11.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

{fastmcp-2.11.1.dist-info → fastmcp-2.11.2.dist-info}/RECORD

@@ -2,17 +2,17 @@ fastmcp/__init__.py,sha256=B_FAqsxbTJmwvJKyIDMOZWpUUdmO806bKo8RR32oZL0,1503
 fastmcp/exceptions.py,sha256=-krEavxwddQau6T7MESCR4VjKNLfP9KHJrU1p3y72FU,744
 fastmcp/mcp_config.py,sha256=jf6VyGHli3GcZNg4spdV1L_lPOeNCKTJh-nGIBaMgn4,10324
 fastmcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastmcp/settings.py,sha256=70cxWrYktvHSOHCgj2rKLJ09HU-pHnfs0jCxxv2Rf80,11131
+fastmcp/settings.py,sha256=LxSDlUmWX2SJLZRjX5ih07jAVIHaFZFRK7RCQPPKAGI,11081
 fastmcp/cli/__init__.py,sha256=Ii284TNoG5lxTP40ETMGhHEq3lQZWxu9m9JuU57kUpQ,87
 fastmcp/cli/claude.py,sha256=IAlcZ4qZKBBj09jZUMEx7EANZE_IR3vcu7zOBJmMOuU,4567
-fastmcp/cli/cli.py,sha256=ovUWG-E3lAfIfKegn2zfYM9oiB0yyPkLViQZd12mYKw,15669
-fastmcp/cli/run.py,sha256=OOdau2sNQsgan4NXucY-3LWOWn6cKjmdALfzht2RXQ0,10508
+fastmcp/cli/cli.py,sha256=32OKZ49JKq3INqIlHXnZfFNTxQ2XYE1UkW3x5iTvtlI,15699
+fastmcp/cli/run.py,sha256=12I_JP4NSbmNqfQT2u14wvl4Uq2Rr_RvlK1z6bgAfOQ,12383
 fastmcp/cli/install/__init__.py,sha256=cDEc0hhuf_xwGpI6ghpqlvlMdBMJUGHq_rs-tgmOJZ8,695
-fastmcp/cli/install/claude_code.py,sha256=ayTZtudjNWHE8MIGeJfb_TmJI3F5K_DHD1X3qEjxEWg,7712
-fastmcp/cli/install/claude_desktop.py,sha256=y8ha2OKM8IuvQbmGNq842q-m-vs_ts2P9cMxAhbBvs4,6872
-fastmcp/cli/install/cursor.py,sha256=q5jXBzpxvoWrgP9pItwNlyl13XpYbtIlZS_dRBkBSdc,6837
-fastmcp/cli/install/mcp_json.py,sha256=uxCN8fsIjJStWtL0J7kfQ9haIJU0SYF8CXYT-crl_o0,5923
-fastmcp/cli/install/shared.py,sha256=Y0YZei1YemVCkg0ieUgfRse-lqSlIn5Ho8t6pB9nDa4,2683
+fastmcp/cli/install/claude_code.py,sha256=1aSO02cJGGWAVl_iVY_dWpShz9Df5ndrAGA_qEj5rbc,7724
+fastmcp/cli/install/claude_desktop.py,sha256=4ErROs-wxdLWr-bCMvL3r9-UIYMETfAghzHTNzhLx5E,6884
+fastmcp/cli/install/cursor.py,sha256=KkRzIBiqaJhmT1wfl3IzprgTnIiAIioTcveq-oDHELE,6849
+fastmcp/cli/install/mcp_json.py,sha256=RUlg7rQiwBysgTOoJfjvVwgz9MFXT-u7aleBDzK1eVQ,5935
+fastmcp/cli/install/shared.py,sha256=T-0R3-WMlmq5uRHYMEVbdItvm6zThzFET4AlI_foG7s,2695
 fastmcp/client/__init__.py,sha256=J-RcLU2WcnYnstXWoW01itGtAg7DEjvCsWyqQKQljoo,663
 fastmcp/client/client.py,sha256=GniETS28L8B-ahzztU2ZLI_XSCcEib-miGzE2ZnG4Xc,34054
 fastmcp/client/elicitation.py,sha256=Jf9yqna8R7r1hqedXAyh9a2-QNVzbCSKUDZhkFHqHqg,2403
@@ -68,8 +68,8 @@ fastmcp/server/elicitation.py,sha256=jZIHjV4NjhYbT-w8pBArwd0vNzP8OYwzmsnWDdk6Bd0
 fastmcp/server/http.py,sha256=idZGs4kRm_eLMscMrlEBIBpX21aiuTlvon9Fizmjswo,11648
 fastmcp/server/low_level.py,sha256=LNmc_nU_wx-fRG8OEHdLPKopZpovcrWlyAxJzKss3TA,1239
 fastmcp/server/openapi.py,sha256=-7-pKwQ1hT-UV9OnLlWrjbbXXRfZld8YJqa4Duybhtw,42102
-fastmcp/server/proxy.py,sha256=4eHW2Vgwe7zvd0g-ozsvYRyIoengyGyhlyMcSPhcaIU,24975
-fastmcp/server/server.py,sha256=hmNiwYFnWhERY-WhxAvS9jIvXOx8_g8ylX-Ju91Y4qk,87597
+fastmcp/server/proxy.py,sha256=soKobVa-c-1Vex7IYnz-jAT526Do2Z4Rs1FaT5ruLro,25651
+fastmcp/server/server.py,sha256=PBDHMx2N2Zr6qVeEs7XEcZrCNObnsAoIrPbK9DlArGk,87634
 fastmcp/server/auth/__init__.py,sha256=ldv13Dsxr2r-VdUV6af6P5qa3wMPQ-MP_yKxsWdlb-4,550
 fastmcp/server/auth/auth.py,sha256=FMkCcht4BMEqKx-SwvfzVC5l7X2moiIzS_ZevaHBq08,10536
 fastmcp/server/auth/registry.py,sha256=4ftVbbuyAi-8zBiJL9-dYIKLU_EOpxY-pFdzHMrmjV8,1306
@@ -93,7 +93,7 @@ fastmcp/utilities/cli.py,sha256=TXuSyALFAGJwi7tWEBwBmaGhYZBdF1aG6dLgl3zjM1w,3272
 fastmcp/utilities/components.py,sha256=wmo1XZBqf_tcOMMN1a-r8d1pT7g--Zmf75f5-vXx5FA,5333
 fastmcp/utilities/exceptions.py,sha256=7Z9j5IzM5rT27BC1Mcn8tkS-bjqCYqMKwb2MMTaxJYU,1350
 fastmcp/utilities/http.py,sha256=1ns1ymBS-WSxbZjGP6JYjSO52Wa_ls4j4WbnXiupoa4,245
-fastmcp/utilities/inspect.py,sha256=XNA0dfYM5G-FVbJaVJO8loSUUCNypyLA-QjqTOneJyU,10833
+fastmcp/utilities/inspect.py,sha256=VLCrh8oMnIg49uuwVO899rUcHhxszPJ1nU0RZ8q2HX8,10639
 fastmcp/utilities/json_schema.py,sha256=Nk6qQKtp0-MlMbRQmx8ps8SJ7SW9CpuWhSes1VASFPQ,8141
 fastmcp/utilities/json_schema_type.py,sha256=fSG-af3OPGgOhuhY_xb0-JsTu5tqi275zXlUw4ItjNo,22287
 fastmcp/utilities/logging.py,sha256=1y7oNmy8WrR0NsfNVw1LPoKu92OFdmzIO65syOKi_BI,1388
@@ -101,8 +101,8 @@ fastmcp/utilities/mcp_config.py,sha256=zzs4VWHqG0eWEnEUwVve7mef_JFThwfvqBYt7nx3j
 fastmcp/utilities/openapi.py,sha256=Jcxu0s9VdA8RSkx1iyoTQwvsny4YCusuuJahyy-TvE8,63300
 fastmcp/utilities/tests.py,sha256=9FVLmGYfUjqfn0pPH33awlTgvg-JCNbnZnraJHNSYTg,6156
 fastmcp/utilities/types.py,sha256=zrF8Oc_L_BdzGj0pqU5ZalM02BisC0_D-d8kcRGccS0,13984
-fastmcp-2.11.1.dist-info/METADATA,sha256=7kstQeYl88_tx9oEhjN98bGmGWskG478FOFlvfCuMiA,17839
-fastmcp-2.11.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastmcp-2.11.1.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
-fastmcp-2.11.1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fastmcp-2.11.1.dist-info/RECORD,,
+fastmcp-2.11.2.dist-info/METADATA,sha256=6OE28R9_gx-82MA3st0SR6dCxsfoH4oftu0jhSjbL10,17839
+fastmcp-2.11.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fastmcp-2.11.2.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
+fastmcp-2.11.2.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fastmcp-2.11.2.dist-info/RECORD,,