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

fastmcp/utilities/cli.py

@@ -1,24 +1,149 @@
 from __future__ import annotations
 
+import json
+import os
 from importlib.metadata import version
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal
 
+from pydantic import ValidationError
+from rich.align import Align
 from rich.console import Console, Group
 from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
 import fastmcp
+from fastmcp.utilities.logging import get_logger
+from fastmcp.utilities.mcp_server_config import MCPServerConfig
+from fastmcp.utilities.mcp_server_config.v1.sources.filesystem import FileSystemSource
+from fastmcp.utilities.types import get_cached_typeadapter
 
 if TYPE_CHECKING:
     from fastmcp import FastMCP
 
+logger = get_logger("cli.config")
+
+
+def is_already_in_uv_subprocess() -> bool:
+    """Check if we're already running in a FastMCP uv subprocess."""
+    return bool(os.environ.get("FASTMCP_UV_SPAWNED"))
+
+
+def load_and_merge_config(
+    server_spec: str | None,
+    **cli_overrides,
+) -> tuple[MCPServerConfig, str]:
+    """Load config from server_spec and apply CLI overrides.
+
+    This consolidates the config parsing logic that was duplicated across
+    run, inspect, and dev commands.
+
+    Args:
+        server_spec: Python file, config file, URL, or None to auto-detect
+        cli_overrides: CLI arguments that override config values
+
+    Returns:
+        Tuple of (MCPServerConfig, resolved_server_spec)
+    """
+    config = None
+    config_path = None
+
+    # Auto-detect fastmcp.json if no server_spec provided
+    if server_spec is None:
+        config_path = Path("fastmcp.json")
+        if not config_path.exists():
+            found_config = MCPServerConfig.find_config()
+            if found_config:
+                config_path = found_config
+            else:
+                logger.error(
+                    "No server specification provided and no fastmcp.json found in current directory.\n"
+                    "Please specify a server file or create a fastmcp.json configuration."
+                )
+                raise FileNotFoundError("No server specification or fastmcp.json found")
+
+        resolved_spec = str(config_path)
+        logger.info(f"Using configuration from {config_path}")
+    else:
+        resolved_spec = server_spec
+
+    # Load config if server_spec is a .json file
+    if resolved_spec.endswith(".json"):
+        config_path = Path(resolved_spec)
+        if config_path.exists():
+            try:
+                with open(config_path) as f:
+                    data = json.load(f)
+
+                # Check if it's an MCPConfig first (has canonical mcpServers key)
+                if "mcpServers" in data:
+                    # MCPConfig - we don't process these here, just pass through
+                    pass
+                else:
+                    # Try to parse as MCPServerConfig
+                    try:
+                        adapter = get_cached_typeadapter(MCPServerConfig)
+                        config = adapter.validate_python(data)
+
+                        # Apply deployment settings
+                        if config.deployment:
+                            config.deployment.apply_runtime_settings(config_path)
+
+                    except ValidationError:
+                        # Not a valid MCPServerConfig, just pass through
+                        pass
+            except (json.JSONDecodeError, FileNotFoundError):
+                # Not a valid JSON file, just pass through
+                pass
+
+    # If we don't have a config object yet, create one from filesystem source
+    if config is None:
+        source = FileSystemSource(path=resolved_spec)
+        config = MCPServerConfig(source=source)
+
+    # Convert to dict for immutable transformation
+    config_dict = config.model_dump()
+
+    # Apply CLI overrides to config's environment (always exists due to default_factory)
+    if python_override := cli_overrides.get("python"):
+        config_dict["environment"]["python"] = python_override
+    if packages_override := cli_overrides.get("with_packages"):
+        # Merge packages - CLI packages are added to config packages
+        existing = config_dict["environment"].get("dependencies") or []
+        config_dict["environment"]["dependencies"] = packages_override + existing
+    if requirements_override := cli_overrides.get("with_requirements"):
+        config_dict["environment"]["requirements"] = str(requirements_override)
+    if project_override := cli_overrides.get("project"):
+        config_dict["environment"]["project"] = str(project_override)
+    if editable_override := cli_overrides.get("editable"):
+        config_dict["environment"]["editable"] = editable_override
+
+    # Apply deployment CLI overrides (always exists due to default_factory)
+    if transport_override := cli_overrides.get("transport"):
+        config_dict["deployment"]["transport"] = transport_override
+    if host_override := cli_overrides.get("host"):
+        config_dict["deployment"]["host"] = host_override
+    if port_override := cli_overrides.get("port"):
+        config_dict["deployment"]["port"] = port_override
+    if path_override := cli_overrides.get("path"):
+        config_dict["deployment"]["path"] = path_override
+    if log_level_override := cli_overrides.get("log_level"):
+        config_dict["deployment"]["log_level"] = log_level_override
+    if server_args_override := cli_overrides.get("server_args"):
+        config_dict["deployment"]["args"] = server_args_override
+
+    # Create new config from modified dict
+    new_config = MCPServerConfig(**config_dict)
+    return new_config, resolved_spec
+
+
 LOGO_ASCII = r"""
-    _ __ ___ ______           __  __  _____________    ____    ____ 
-   _ __ ___ / ____/___ ______/ /_/  |/  / ____/ __ \  |___ \  / __ \
+    _ __ ___  _____           __  __  _____________    ____    ____ 
+   _ __ ___ .'____/___ ______/ /_/  |/  / ____/ __ \  |___ \  / __ \
   _ __ ___ / /_  / __ `/ ___/ __/ /|_/ / /   / /_/ /  ___/ / / / / /
  _ __ ___ / __/ / /_/ (__  ) /_/ /  / / /___/ ____/  /  __/_/ /_/ / 
-_ __ ___ /_/    \__,_/____/\__/_/  /_/\____/_/      /_____(_)____/  
+_ __ ___ /_/    \____/____/\__/_/  /_/\____/_/      /_____(*)____/  
 
 """.lstrip("\n")
 
@@ -44,11 +169,14 @@ def log_server_banner(
     # Create the logo text
     logo_text = Text(LOGO_ASCII, style="bold green")
 
+    # Create the main title
+    title_text = Text("FastMCP  2.0", style="bold blue")
+
     # Create the information table
     info_table = Table.grid(padding=(0, 1))
     info_table.add_column(style="bold", justify="center")  # Emoji column
-    info_table.add_column(style="bold cyan", justify="left")  # Label column
-    info_table.add_column(style="white", justify="left")  # Value column
+    info_table.add_column(style="cyan", justify="left")  # Label column
+    info_table.add_column(style="dim", justify="left")  # Value column
 
     match transport:
         case "http" | "streamable-http":
@@ -69,11 +197,6 @@ def log_server_banner(
                 server_url += f"/{path.lstrip('/')}"
             info_table.add_row("🔗", "Server URL:", server_url)
 
-    # Add documentation link
-    info_table.add_row("", "", "")
-    info_table.add_row("📚", "Docs:", "https://gofastmcp.com")
-    info_table.add_row("🚀", "Deploy:", "https://fastmcp.cloud")
-
     # Add version information with explicit style overrides
     info_table.add_row("", "", "")
     info_table.add_row(
@@ -83,16 +206,26 @@ def log_server_banner(
     )
     info_table.add_row(
         "🤝",
-        "MCP version:",
+        "MCP SDK version:",
         Text(version("mcp"), style="dim white", no_wrap=True),
     )
-    # Create panel with logo and information using Group
-    panel_content = Group(logo_text, "", info_table)
+
+    # Add documentation link
+    info_table.add_row("", "", "")
+    info_table.add_row("📚", "Docs:", "https://gofastmcp.com")
+    info_table.add_row("🚀", "Deploy:", "https://fastmcp.cloud")
+
+    # Create panel with logo, title, and information using Group
+    panel_content = Group(
+        Align.center(logo_text),
+        Align.center(title_text),
+        "",
+        "",
+        Align.center(info_table),
+    )
 
     panel = Panel(
         panel_content,
-        title="FastMCP 2.0",
-        title_align="left",
         border_style="dim",
         padding=(1, 4),
         expand=False,

fastmcp/utilities/components.py

@@ -117,7 +117,8 @@ class FastMCPComponent(FastMCPBaseModel):
     def __eq__(self, other: object) -> bool:
         if type(self) is not type(other):
             return False
-        assert isinstance(other, type(self))
+        if not isinstance(other, type(self)):
+            return False
         return self.model_dump() == other.model_dump()
 
     def __repr__(self) -> str:

fastmcp/utilities/inspect.py

@@ -4,8 +4,10 @@ from __future__ import annotations
 
 import importlib.metadata
 from dataclasses import dataclass
-from typing import Any
+from enum import Enum
+from typing import Any, Literal, cast
 
+import pydantic_core
 from mcp.server.fastmcp import FastMCP as FastMCP1x
 
 import fastmcp
@@ -21,9 +23,12 @@ class ToolInfo:
     name: str
     description: str | None
     input_schema: dict[str, Any]
+    output_schema: dict[str, Any] | None = None
     annotations: dict[str, Any] | None = None
     tags: list[str] | None = None
     enabled: bool | None = None
+    title: str | None = None
+    meta: dict[str, Any] | None = None
 
 
 @dataclass
@@ -36,6 +41,8 @@ class PromptInfo:
     arguments: list[dict[str, Any]] | None = None
     tags: list[str] | None = None
     enabled: bool | None = None
+    title: str | None = None
+    meta: dict[str, Any] | None = None
 
 
 @dataclass
@@ -47,8 +54,11 @@ class ResourceInfo:
     name: str | None
     description: str | None
     mime_type: str | None = None
+    annotations: dict[str, Any] | None = None
     tags: list[str] | None = None
     enabled: bool | None = None
+    title: str | None = None
+    meta: dict[str, Any] | None = None
 
 
 @dataclass
@@ -60,8 +70,12 @@ class TemplateInfo:
     name: str | None
     description: str | None
     mime_type: str | None = None
+    parameters: dict[str, Any] | None = None
+    annotations: dict[str, Any] | None = None
     tags: list[str] | None = None
     enabled: bool | None = None
+    title: str | None = None
+    meta: dict[str, Any] | None = None
 
 
 @dataclass
@@ -70,9 +84,10 @@ class FastMCPInfo:
 
     name: str
     instructions: str | None
-    fastmcp_version: str
-    mcp_version: str
-    server_version: str | None
+    version: str | None  # The server's own version string (if specified)
+    fastmcp_version: str  # Version of FastMCP generating this manifest
+    mcp_version: str  # Version of MCP protocol library
+    server_generation: int  # Server generation: 1 (mcp package) or 2 (fastmcp)
     tools: list[ToolInfo]
     prompts: list[PromptInfo]
     resources: list[ResourceInfo]
@@ -106,9 +121,12 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
                 name=tool.name or key,
                 description=tool.description,
                 input_schema=mcp_tool.inputSchema if mcp_tool.inputSchema else {},
+                output_schema=tool.output_schema,
                 annotations=tool.annotations.model_dump() if tool.annotations else None,
                 tags=list(tool.tags) if tool.tags else None,
                 enabled=tool.enabled,
+                title=tool.title,
+                meta=tool.meta,
             )
         )
 
@@ -125,6 +143,8 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
                 else None,
                 tags=list(prompt.tags) if prompt.tags else None,
                 enabled=prompt.enabled,
+                title=prompt.title,
+                meta=prompt.meta,
             )
         )
 
@@ -138,8 +158,13 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
                 name=resource.name,
                 description=resource.description,
                 mime_type=resource.mime_type,
+                annotations=resource.annotations.model_dump()
+                if resource.annotations
+                else None,
                 tags=list(resource.tags) if resource.tags else None,
                 enabled=resource.enabled,
+                title=resource.title,
+                meta=resource.meta,
             )
         )
 
@@ -153,8 +178,14 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
                 name=template.name,
                 description=template.description,
                 mime_type=template.mime_type,
+                parameters=template.parameters,
+                annotations=template.annotations.model_dump()
+                if template.annotations
+                else None,
                 tags=list(template.tags) if template.tags else None,
                 enabled=template.enabled,
+                title=template.title,
+                meta=template.meta,
             )
         )
 
@@ -171,9 +202,8 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
         instructions=mcp.instructions,
         fastmcp_version=fastmcp.__version__,
         mcp_version=importlib.metadata.version("mcp"),
-        server_version=(
-            mcp.version if hasattr(mcp, "version") else mcp._mcp_server.version
-        ),
+        server_generation=2,  # FastMCP v2
+        version=(mcp.version if hasattr(mcp, "version") else mcp._mcp_server.version),
         tools=tool_infos,
         prompts=prompt_infos,
         resources=resource_infos,
@@ -191,7 +221,6 @@ async def inspect_fastmcp_v1(mcp: FastMCP1x) -> FastMCPInfo:
     Returns:
         FastMCPInfo dataclass containing the extracted information
     """
-
     # Use a client to interact with the FastMCP1x server
     async with Client(mcp) as client:
         # Get components via client calls (these return MCP objects)
@@ -208,25 +237,18 @@ async def inspect_fastmcp_v1(mcp: FastMCP1x) -> FastMCPInfo:
         # Extract detailed tool information from MCP Tool objects
         tool_infos = []
         for mcp_tool in mcp_tools:
-            # Extract annotations if they exist
-            annotations = None
-            if hasattr(mcp_tool, "annotations") and mcp_tool.annotations:
-                if hasattr(mcp_tool.annotations, "model_dump"):
-                    annotations = mcp_tool.annotations.model_dump()
-                elif isinstance(mcp_tool.annotations, dict):
-                    annotations = mcp_tool.annotations
-                else:
-                    annotations = None
-
             tool_infos.append(
                 ToolInfo(
-                    key=mcp_tool.name,  # For 1.x, key and name are the same
+                    key=mcp_tool.name,
                     name=mcp_tool.name,
                     description=mcp_tool.description,
                     input_schema=mcp_tool.inputSchema if mcp_tool.inputSchema else {},
-                    annotations=annotations,
-                    tags=None,  # 1.x doesn't have tags
-                    enabled=None,  # 1.x doesn't have enabled field
+                    output_schema=None,  # v1 doesn't have output_schema
+                    annotations=None,  # v1 doesn't have annotations
+                    tags=None,  # v1 doesn't have tags
+                    enabled=None,  # v1 doesn't have enabled field
+                    title=None,  # v1 doesn't have title
+                    meta=None,  # v1 doesn't have meta field
                 )
             )
 
@@ -240,12 +262,14 @@ async def inspect_fastmcp_v1(mcp: FastMCP1x) -> FastMCPInfo:
 
             prompt_infos.append(
                 PromptInfo(
-                    key=mcp_prompt.name,  # For 1.x, key and name are the same
+                    key=mcp_prompt.name,
                     name=mcp_prompt.name,
                     description=mcp_prompt.description,
                     arguments=arguments,
-                    tags=None,  # 1.x doesn't have tags
-                    enabled=None,  # 1.x doesn't have enabled field
+                    tags=None,  # v1 doesn't have tags
+                    enabled=None,  # v1 doesn't have enabled field
+                    title=None,  # v1 doesn't have title
+                    meta=None,  # v1 doesn't have meta field
                 )
             )
 
@@ -254,13 +278,16 @@ async def inspect_fastmcp_v1(mcp: FastMCP1x) -> FastMCPInfo:
         for mcp_resource in mcp_resources:
             resource_infos.append(
                 ResourceInfo(
-                    key=str(mcp_resource.uri),  # For 1.x, key and uri are the same
+                    key=str(mcp_resource.uri),
                     uri=str(mcp_resource.uri),
                     name=mcp_resource.name,
                     description=mcp_resource.description,
                     mime_type=mcp_resource.mimeType,
-                    tags=None,  # 1.x doesn't have tags
-                    enabled=None,  # 1.x doesn't have enabled field
+                    annotations=None,  # v1 doesn't have annotations
+                    tags=None,  # v1 doesn't have tags
+                    enabled=None,  # v1 doesn't have enabled field
+                    title=None,  # v1 doesn't have title
+                    meta=None,  # v1 doesn't have meta field
                 )
             )
 
@@ -269,15 +296,17 @@ async def inspect_fastmcp_v1(mcp: FastMCP1x) -> FastMCPInfo:
         for mcp_template in mcp_templates:
             template_infos.append(
                 TemplateInfo(
-                    key=str(
-                        mcp_template.uriTemplate
-                    ),  # For 1.x, key and uriTemplate are the same
+                    key=str(mcp_template.uriTemplate),
                     uri_template=str(mcp_template.uriTemplate),
                     name=mcp_template.name,
                     description=mcp_template.description,
                     mime_type=mcp_template.mimeType,
-                    tags=None,  # 1.x doesn't have tags
-                    enabled=None,  # 1.x doesn't have enabled field
+                    parameters=None,  # v1 doesn't expose template parameters
+                    annotations=None,  # v1 doesn't have annotations
+                    tags=None,  # v1 doesn't have tags
+                    enabled=None,  # v1 doesn't have enabled field
+                    title=None,  # v1 doesn't have title
+                    meta=None,  # v1 doesn't have meta field
                 )
             )
 
@@ -292,13 +321,14 @@ async def inspect_fastmcp_v1(mcp: FastMCP1x) -> FastMCPInfo:
         return FastMCPInfo(
             name=mcp._mcp_server.name,
             instructions=mcp._mcp_server.instructions,
-            fastmcp_version=importlib.metadata.version("mcp"),
+            fastmcp_version=fastmcp.__version__,  # Version generating this manifest
             mcp_version=importlib.metadata.version("mcp"),
-            server_version=mcp._mcp_server.version,
+            server_generation=1,  # MCP v1
+            version=mcp._mcp_server.version,
             tools=tool_infos,
             prompts=prompt_infos,
             resources=resource_infos,
-            templates=template_infos,  # FastMCP1x does have templates
+            templates=template_infos,
             capabilities=capabilities,
         )
 
@@ -318,4 +348,103 @@ async def inspect_fastmcp(mcp: FastMCP[Any] | FastMCP1x) -> FastMCPInfo:
     if isinstance(mcp, FastMCP1x):
         return await inspect_fastmcp_v1(mcp)
     else:
-        return await inspect_fastmcp_v2(mcp)
+        return await inspect_fastmcp_v2(cast(FastMCP[Any], mcp))
+
+
+class InspectFormat(str, Enum):
+    """Output format for inspect command."""
+
+    FASTMCP = "fastmcp"
+    MCP = "mcp"
+
+
+async def format_fastmcp_info(info: FastMCPInfo) -> bytes:
+    """Format FastMCPInfo as FastMCP-specific JSON.
+
+    This includes FastMCP-specific fields like tags, enabled, annotations, etc.
+    """
+    # Build the output dict with nested structure
+    result = {
+        "server": {
+            "name": info.name,
+            "instructions": info.instructions,
+            "version": info.version,
+            "generation": info.server_generation,
+            "capabilities": info.capabilities,
+        },
+        "environment": {
+            "fastmcp": info.fastmcp_version,
+            "mcp": info.mcp_version,
+        },
+        "tools": info.tools,
+        "prompts": info.prompts,
+        "resources": info.resources,
+        "templates": info.templates,
+    }
+
+    return pydantic_core.to_json(result, indent=2)
+
+
+async def format_mcp_info(mcp: FastMCP[Any] | FastMCP1x) -> bytes:
+    """Format server info as standard MCP protocol JSON.
+
+    Uses Client to get the standard MCP protocol format with camelCase fields.
+    Includes version metadata at the top level.
+    """
+    async with Client(mcp) as client:
+        # Get all the MCP protocol objects
+        tools_result = await client.list_tools_mcp()
+        prompts_result = await client.list_prompts_mcp()
+        resources_result = await client.list_resources_mcp()
+        templates_result = await client.list_resource_templates_mcp()
+
+        # Get server info from the initialize result
+        server_info = client.initialize_result.serverInfo
+
+        # Combine into MCP protocol structure with environment metadata
+        result = {
+            "environment": {
+                "fastmcp": fastmcp.__version__,  # Version generating this manifest
+                "mcp": importlib.metadata.version("mcp"),  # MCP protocol version
+            },
+            "serverInfo": server_info,
+            "capabilities": {},  # MCP format doesn't include capabilities at top level
+            "tools": tools_result.tools,
+            "prompts": prompts_result.prompts,
+            "resources": resources_result.resources,
+            "resourceTemplates": templates_result.resourceTemplates,
+        }
+
+        return pydantic_core.to_json(result, indent=2)
+
+
+async def format_info(
+    mcp: FastMCP[Any] | FastMCP1x,
+    format: InspectFormat | Literal["fastmcp", "mcp"],
+    info: FastMCPInfo | None = None,
+) -> bytes:
+    """Format server information according to the specified format.
+
+    Args:
+        mcp: The FastMCP instance
+        format: Output format ("fastmcp" or "mcp")
+        info: Pre-extracted FastMCPInfo (optional, will be extracted if not provided)
+
+    Returns:
+        JSON bytes in the requested format
+    """
+    # Convert string to enum if needed
+    if isinstance(format, str):
+        format = InspectFormat(format)
+
+    if format == InspectFormat.MCP:
+        # MCP format doesn't need FastMCPInfo, it uses Client directly
+        return await format_mcp_info(mcp)
+    elif format == InspectFormat.FASTMCP:
+        # For FastMCP format, we need the FastMCPInfo
+        # This works for both v1 and v2 servers
+        if info is None:
+            info = await inspect_fastmcp(mcp)
+        return await format_fastmcp_info(info)
+    else:
+        raise ValueError(f"Unknown format: {format}")

fastmcp/utilities/json_schema_type.py

@@ -449,7 +449,8 @@ def _create_pydantic_model(
 ) -> type:
     """Create Pydantic BaseModel from object schema with additionalProperties."""
     name = name or schema.get("title", "Root")
-    assert name is not None  # Should not be None after the or operation
+    if name is None:
+        raise ValueError("Name is required")
     sanitized_name = _sanitize_name(name)
     schema_hash = _hash_schema(schema)
     cache_key = (schema_hash, sanitized_name)
@@ -507,7 +508,8 @@ def _create_dataclass(
     """Create dataclass from object schema."""
     name = name or schema.get("title", "Root")
     # Sanitize name for class creation
-    assert name is not None  # Should not be None after the or operation
+    if name is None:
+        raise ValueError("Name is required")
     sanitized_name = _sanitize_name(name)
     schema_hash = _hash_schema(schema)
     cache_key = (schema_hash, sanitized_name)

fastmcp/utilities/logging.py

@@ -1,7 +1,7 @@
 """Logging utilities for FastMCP."""
 
 import logging
-from typing import Literal
+from typing import Any, Literal
 
 from rich.console import Console
 from rich.logging import RichHandler
@@ -23,6 +23,7 @@ def configure_logging(
     level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | int = "INFO",
     logger: logging.Logger | None = None,
     enable_rich_tracebacks: bool = True,
+    **rich_kwargs: Any,
 ) -> None:
     """
     Configure logging for FastMCP.
@@ -30,6 +31,7 @@ def configure_logging(
     Args:
         logger: the logger to configure
         level: the log level to use
+        rich_kwargs: the parameters to use for creating RichHandler
     """
 
     if logger is None:
@@ -39,6 +41,7 @@ def configure_logging(
     handler = RichHandler(
         console=Console(stderr=True),
         rich_tracebacks=enable_rich_tracebacks,
+        **rich_kwargs,
     )
     formatter = logging.Formatter("%(message)s")
     handler.setFormatter(formatter)