fastmcp 2.11.1__py3-none-any.whl → 2.11.3__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/client/logging.py

@@ -13,7 +13,31 @@ LogHandler: TypeAlias = Callable[[LogMessage], Awaitable[None]]
 
 
 async def default_log_handler(message: LogMessage) -> None:
-    logger.debug(f"Log received: {message}")
+    """Default handler that properly routes server log messages to appropriate log levels."""
+    msg = message.data.get("msg", str(message))
+    extra = message.data.get("extra", {})
+
+    # Map MCP log levels to Python logging levels
+    level_map = {
+        "debug": logger.debug,
+        "info": logger.info,
+        "notice": logger.info,  # Python doesn't have 'notice', map to info
+        "warning": logger.warning,
+        "error": logger.error,
+        "critical": logger.critical,
+        "alert": logger.critical,  # Map alert to critical
+        "emergency": logger.critical,  # Map emergency to critical
+    }
+
+    # Get the appropriate logging function based on the message level
+    log_fn = level_map.get(message.level.lower(), logger.info)
+
+    # Include logger name if available
+    if message.logger:
+        msg = f"[{message.logger}] {msg}"
+
+    # Log with appropriate level and extra data
+    log_fn(f"Server log: {msg}", extra=extra)
 
 
 def create_log_callback(handler: LogHandler | None = None) -> LoggingFnT:

fastmcp/client/transports.py

@@ -6,7 +6,7 @@ import os
 import shutil
 import sys
 import warnings
-from collections.abc import AsyncIterator, Callable
+from collections.abc import AsyncIterator
 from pathlib import Path
 from typing import Any, Literal, TypeVar, cast, overload
 
@@ -22,6 +22,7 @@ from mcp.client.session import (
     SamplingFnT,
 )
 from mcp.server.fastmcp import FastMCP as FastMCP1Server
+from mcp.shared._httpx_utils import McpHttpClientFactory
 from mcp.shared.memory import create_client_server_memory_streams
 from pydantic import AnyUrl
 from typing_extensions import TypedDict, Unpack
@@ -161,7 +162,7 @@ class SSETransport(ClientTransport):
         headers: dict[str, str] | None = None,
         auth: httpx.Auth | Literal["oauth"] | str | None = None,
         sse_read_timeout: datetime.timedelta | float | int | None = None,
-        httpx_client_factory: Callable[[], httpx.AsyncClient] | None = None,
+        httpx_client_factory: McpHttpClientFactory | None = None,
     ):
         if isinstance(url, AnyUrl):
             url = str(url)
@@ -233,7 +234,7 @@ class StreamableHttpTransport(ClientTransport):
         headers: dict[str, str] | None = None,
         auth: httpx.Auth | Literal["oauth"] | str | None = None,
         sse_read_timeout: datetime.timedelta | float | int | None = None,
-        httpx_client_factory: Callable[[], httpx.AsyncClient] | None = None,
+        httpx_client_factory: McpHttpClientFactory | None = None,
     ):
         if isinstance(url, AnyUrl):
             url = str(url)

fastmcp/experimental/server/openapi/routing.py

@@ -113,7 +113,7 @@ def _determine_route_type(
                 # We know mcp_type is not None here due to post_init validation
                 assert route_map.mcp_type is not None
                 logger.debug(
-                    f"Route {route.method} {route.path} matched mapping to {route_map.mcp_type.name}"
+                    f"Route {route.method} {route.path} mapped to {route_map.mcp_type.name}"
                 )
                 return route_map
 

fastmcp/experimental/server/openapi/server.py

@@ -11,7 +11,7 @@ from jsonschema_path import SchemaPath
 from fastmcp.experimental.utilities.openapi import (
     HTTPRoute,
     extract_output_schema_from_responses,
-    format_description_with_responses,
+    format_simple_description,
     parse_openapi_to_http_routes,
 )
 from fastmcp.experimental.utilities.openapi.director import RequestDirector
@@ -151,9 +151,6 @@ class FastMCPOpenAPI(FastMCP):
         try:
             self._spec = SchemaPath.from_dict(openapi_spec)  # type: ignore[arg-type]
             self._director = RequestDirector(self._spec)
-            logger.debug(
-                "Initialized OpenAPI RequestDirector for stateless request building"
-            )
         except Exception as e:
             logger.error(f"Failed to initialize RequestDirector: {e}")
             raise ValueError(f"Invalid OpenAPI specification: {e}") from e
@@ -270,7 +267,9 @@ class FastMCPOpenAPI(FastMCP):
 
         # Extract output schema from OpenAPI responses
         output_schema = extract_output_schema_from_responses(
-            route.responses, route.schema_definitions, route.openapi_version
+            route.responses,
+            route.response_schemas,
+            route.openapi_version,
         )
 
         # Get a unique tool name
@@ -282,10 +281,9 @@ class FastMCPOpenAPI(FastMCP):
             or f"Executes {route.method} {route.path}"
         )
 
-        # Format enhanced description with parameters and request body
-        enhanced_description = format_description_with_responses(
+        # Use simplified description formatter for tools
+        enhanced_description = format_simple_description(
             base_description=base_description,
-            responses=route.responses,
             parameters=route.parameters,
             request_body=route.request_body,
         )
@@ -318,9 +316,6 @@ class FastMCPOpenAPI(FastMCP):
 
         # Register the tool by directly assigning to the tools dictionary
         self._tool_manager._tools[final_tool_name] = tool
-        logger.debug(
-            f"Registered TOOL: {final_tool_name} ({route.method} {route.path}) with tags: {route.tags}"
-        )
 
     def _create_openapi_resource(
         self,
@@ -337,10 +332,9 @@ class FastMCPOpenAPI(FastMCP):
             route.description or route.summary or f"Represents {route.path}"
         )
 
-        # Format enhanced description with parameters and request body
-        enhanced_description = format_description_with_responses(
+        # Use simplified description for resources
+        enhanced_description = format_simple_description(
             base_description=base_description,
-            responses=route.responses,
             parameters=route.parameters,
             request_body=route.request_body,
         )
@@ -372,9 +366,6 @@ class FastMCPOpenAPI(FastMCP):
 
         # Register the resource by directly assigning to the resources dictionary
         self._resource_manager._resources[final_resource_uri] = resource
-        logger.debug(
-            f"Registered RESOURCE: {final_resource_uri} ({route.method} {route.path}) with tags: {route.tags}"
-        )
 
     def _create_openapi_template(
         self,
@@ -397,10 +388,9 @@ class FastMCPOpenAPI(FastMCP):
             route.description or route.summary or f"Template for {route.path}"
         )
 
-        # Format enhanced description with parameters and request body
-        enhanced_description = format_description_with_responses(
+        # Use simplified description for resource templates
+        enhanced_description = format_simple_description(
             base_description=base_description,
-            responses=route.responses,
             parameters=route.parameters,
             request_body=route.request_body,
         )
@@ -455,9 +445,6 @@ class FastMCPOpenAPI(FastMCP):
 
         # Register the template by directly assigning to the templates dictionary
         self._resource_manager._templates[final_template_uri] = template
-        logger.debug(
-            f"Registered TEMPLATE: {final_template_uri} ({route.method} {route.path}) with tags: {route.tags}"
-        )
 
 
 # Export public symbols

fastmcp/experimental/utilities/openapi/__init__.py

@@ -20,6 +20,7 @@ from .formatters import (
     format_deep_object_parameter,
     format_description_with_responses,
     format_json_for_description,
+    format_simple_description,
     generate_example_from_schema,
 )
 
@@ -28,7 +29,6 @@ from .schemas import (
     _combine_schemas,
     extract_output_schema_from_responses,
     clean_schema_for_display,
-    _replace_ref_with_defs,
     _make_optional_parameter_nullable,
 )
 
@@ -55,12 +55,12 @@ __all__ = [
     "format_deep_object_parameter",
     "format_description_with_responses",
     "format_json_for_description",
+    "format_simple_description",
     "generate_example_from_schema",
     # Schemas
     "_combine_schemas",
     "extract_output_schema_from_responses",
     "clean_schema_for_display",
-    "_replace_ref_with_defs",
     "_make_optional_parameter_nullable",
     # JSON Schema Converter
     "convert_openapi_schema_to_json_schema",

fastmcp/experimental/utilities/openapi/formatters.py

@@ -189,6 +189,39 @@ def format_json_for_description(data: Any, indent: int = 2) -> str:
         return f"```\nCould not serialize to JSON: {data}\n```"
 
 
+def format_simple_description(
+    base_description: str,
+    parameters: list[ParameterInfo] | None = None,
+    request_body: RequestBodyInfo | None = None,
+) -> str:
+    """
+    Formats a simple description for MCP objects (tools, resources, prompts).
+    Excludes response details, examples, and verbose status codes.
+
+    Args:
+        base_description (str): The initial description to be formatted.
+        parameters (list[ParameterInfo] | None, optional): A list of parameter information.
+        request_body (RequestBodyInfo | None, optional): Information about the request body.
+
+    Returns:
+        str: The formatted description string with minimal details.
+    """
+    desc_parts = [base_description]
+
+    # Only add critical parameter information if they have descriptions
+    if parameters:
+        path_params = [p for p in parameters if p.location == "path" and p.description]
+        if path_params:
+            desc_parts.append("\n\n**Path Parameters:**")
+            for param in path_params:
+                desc_parts.append(f"\n- **{param.name}**: {param.description}")
+
+    # Skip query parameters, request body details, and all response information
+    # These are already captured in the inputSchema
+
+    return "\n".join(desc_parts)
+
+
 def format_description_with_responses(
     base_description: str,
     responses: dict[
@@ -351,5 +384,6 @@ __all__ = [
     "format_deep_object_parameter",
     "format_description_with_responses",
     "format_json_for_description",
+    "format_simple_description",
     "generate_example_from_schema",
 ]

fastmcp/experimental/utilities/openapi/models.py

@@ -58,9 +58,12 @@ class HTTPRoute(FastMCPBaseModel):
     responses: dict[str, ResponseInfo] = Field(
         default_factory=dict
     )  # Key: status code str
-    schema_definitions: dict[str, JsonSchema] = Field(
+    request_schemas: dict[str, JsonSchema] = Field(
         default_factory=dict
-    )  # Store component schemas
+    )  # Store schemas needed for input (parameters/request body)
+    response_schemas: dict[str, JsonSchema] = Field(
+        default_factory=dict
+    )  # Store schemas needed for output (responses)
     extensions: dict[str, Any] = Field(default_factory=dict)
     openapi_version: str | None = None