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

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)

fastmcp/utilities/mcp_config.py

@@ -1,28 +1,57 @@
 from typing import Any
 
-from fastmcp.mcp_config import MCPConfig
+from fastmcp.client.transports import (
+    ClientTransport,
+    SSETransport,
+    StdioTransport,
+    StreamableHttpTransport,
+)
+from fastmcp.mcp_config import (
+    MCPConfig,
+    MCPServerTypes,
+)
+from fastmcp.server.proxy import FastMCPProxy, ProxyClient
 from fastmcp.server.server import FastMCP
 
 
-def composite_server_from_mcp_config(
-    config: MCPConfig, name_as_prefix: bool = True
-) -> FastMCP[None]:
-    """A utility function to create a composite server from an MCPConfig."""
-    composite_server = FastMCP[None]()
+def mcp_config_to_servers_and_transports(
+    config: MCPConfig,
+) -> list[tuple[str, FastMCP[Any], ClientTransport]]:
+    """A utility function to convert each entry of an MCP Config into a transport and server."""
+    return [
+        mcp_server_type_to_servers_and_transports(name, mcp_server)
+        for name, mcp_server in config.mcpServers.items()
+    ]
 
-    mount_mcp_config_into_server(config, composite_server, name_as_prefix)
 
-    return composite_server
+def mcp_server_type_to_servers_and_transports(
+    name: str,
+    mcp_server: MCPServerTypes,
+) -> tuple[str, FastMCP[Any], ClientTransport]:
+    """A utility function to convert each entry of an MCP Config into a transport and server."""
 
+    from fastmcp.mcp_config import (
+        TransformingRemoteMCPServer,
+        TransformingStdioMCPServer,
+    )
 
-def mount_mcp_config_into_server(
-    config: MCPConfig,
-    server: FastMCP[Any],
-    name_as_prefix: bool = True,
-) -> None:
-    """A utility function to mount the servers from an MCPConfig into a FastMCP server."""
-    for name, mcp_server in config.mcpServers.items():
-        server.mount(
-            prefix=name if name_as_prefix else None,
-            server=FastMCP.as_proxy(backend=mcp_server.to_transport()),
+    server: FastMCP[Any]
+    transport: ClientTransport
+
+    client_name = ProxyClient.generate_name(f"MCP_{name}")
+    server_name = FastMCPProxy.generate_name(f"MCP_{name}")
+
+    if isinstance(mcp_server, TransformingRemoteMCPServer | TransformingStdioMCPServer):
+        server, transport = mcp_server._to_server_and_underlying_transport(
+            server_name=server_name,
+            client_name=client_name,
         )
+    else:
+        transport = mcp_server.to_transport()
+        client: ProxyClient[StreamableHttpTransport | SSETransport | StdioTransport] = (
+            ProxyClient(transport=transport, name=client_name)
+        )
+
+        server = FastMCP.as_proxy(name=server_name, backend=client)
+
+    return name, server, transport

fastmcp/utilities/mcp_server_config/__init__.py

@@ -0,0 +1,25 @@
+"""FastMCP Configuration module.
+
+This module provides versioned configuration support for FastMCP servers.
+The current version is v1, which is re-exported here for convenience.
+"""
+
+from fastmcp.utilities.mcp_server_config.v1.environments.base import Environment
+from fastmcp.utilities.mcp_server_config.v1.environments.uv import UVEnvironment
+from fastmcp.utilities.mcp_server_config.v1.mcp_server_config import (
+    Deployment,
+    MCPServerConfig,
+    generate_schema,
+)
+from fastmcp.utilities.mcp_server_config.v1.sources.base import Source
+from fastmcp.utilities.mcp_server_config.v1.sources.filesystem import FileSystemSource
+
+__all__ = [
+    "Source",
+    "Deployment",
+    "Environment",
+    "UVEnvironment",
+    "MCPServerConfig",
+    "FileSystemSource",
+    "generate_schema",
+]

fastmcp/utilities/mcp_server_config/v1/environments/__init__.py

@@ -0,0 +1,6 @@
+"""Environment configuration for MCP servers."""
+
+from fastmcp.utilities.mcp_server_config.v1.environments.base import Environment
+from fastmcp.utilities.mcp_server_config.v1.environments.uv import UVEnvironment
+
+__all__ = ["Environment", "UVEnvironment"]

fastmcp/utilities/mcp_server_config/v1/environments/base.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+
+class Environment(BaseModel, ABC):
+    """Base class for environment configuration."""
+
+    type: str = Field(description="Environment type identifier")
+
+    @abstractmethod
+    def build_command(self, command: list[str]) -> list[str]:
+        """Build the full command with environment setup.
+
+        Args:
+            command: Base command to wrap with environment setup
+
+        Returns:
+            Full command ready for subprocess execution
+        """
+        pass
+
+    async def prepare(self, output_dir: Path | None = None) -> None:
+        """Prepare the environment (optional, can be no-op).
+
+        Args:
+            output_dir: Directory for persistent environment setup
+        """
+        pass  # Default no-op implementation