fastmcp 2.12.1__py3-none-any.whl → 2.13.2__py3-none-any.whl

fastmcp/utilities/inspect.py

@@ -28,6 +28,7 @@ class ToolInfo:
     tags: list[str] | None = None
     enabled: bool | None = None
     title: str | None = None
+    icons: list[dict[str, Any]] | None = None
     meta: dict[str, Any] | None = None
 
 
@@ -42,6 +43,7 @@ class PromptInfo:
     tags: list[str] | None = None
     enabled: bool | None = None
     title: str | None = None
+    icons: list[dict[str, Any]] | None = None
     meta: dict[str, Any] | None = None
 
 
@@ -58,6 +60,7 @@ class ResourceInfo:
     tags: list[str] | None = None
     enabled: bool | None = None
     title: str | None = None
+    icons: list[dict[str, Any]] | None = None
     meta: dict[str, Any] | None = None
 
 
@@ -75,6 +78,7 @@ class TemplateInfo:
     tags: list[str] | None = None
     enabled: bool | None = None
     title: str | None = None
+    icons: list[dict[str, Any]] | None = None
     meta: dict[str, Any] | None = None
 
 
@@ -85,6 +89,8 @@ class FastMCPInfo:
     name: str
     instructions: str | None
     version: str | None  # The server's own version string (if specified)
+    website_url: str | None
+    icons: list[dict[str, Any]] | None
     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)
@@ -104,21 +110,20 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
     Returns:
         FastMCPInfo dataclass containing the extracted information
     """
-    # Get all the components using FastMCP2's direct methods
-    tools_dict = await mcp.get_tools()
-    prompts_dict = await mcp.get_prompts()
-    resources_dict = await mcp.get_resources()
-    templates_dict = await mcp.get_resource_templates()
+    # Get all components via middleware to respect filtering and preserve metadata
+    tools_list = await mcp._list_tools_middleware()
+    prompts_list = await mcp._list_prompts_middleware()
+    resources_list = await mcp._list_resources_middleware()
+    templates_list = await mcp._list_resource_templates_middleware()
 
     # Extract detailed tool information
     tool_infos = []
-    for key, tool in tools_dict.items():
-        # Convert to MCP tool to get input schema
-        mcp_tool = tool.to_mcp_tool(name=key)
+    for tool in tools_list:
+        mcp_tool = tool.to_mcp_tool(name=tool.key)
         tool_infos.append(
             ToolInfo(
-                key=key,
-                name=tool.name or key,
+                key=tool.key,
+                name=tool.name or tool.key,
                 description=tool.description,
                 input_schema=mcp_tool.inputSchema if mcp_tool.inputSchema else {},
                 output_schema=tool.output_schema,
@@ -126,17 +131,20 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
                 tags=list(tool.tags) if tool.tags else None,
                 enabled=tool.enabled,
                 title=tool.title,
+                icons=[icon.model_dump() for icon in tool.icons]
+                if tool.icons
+                else None,
                 meta=tool.meta,
             )
         )
 
     # Extract detailed prompt information
     prompt_infos = []
-    for key, prompt in prompts_dict.items():
+    for prompt in prompts_list:
         prompt_infos.append(
             PromptInfo(
-                key=key,
-                name=prompt.name or key,
+                key=prompt.key,
+                name=prompt.name or prompt.key,
                 description=prompt.description,
                 arguments=[arg.model_dump() for arg in prompt.arguments]
                 if prompt.arguments
@@ -144,17 +152,20 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
                 tags=list(prompt.tags) if prompt.tags else None,
                 enabled=prompt.enabled,
                 title=prompt.title,
+                icons=[icon.model_dump() for icon in prompt.icons]
+                if prompt.icons
+                else None,
                 meta=prompt.meta,
             )
         )
 
     # Extract detailed resource information
     resource_infos = []
-    for key, resource in resources_dict.items():
+    for resource in resources_list:
         resource_infos.append(
             ResourceInfo(
-                key=key,
-                uri=key,  # For v2, key is the URI
+                key=resource.key,
+                uri=resource.key,
                 name=resource.name,
                 description=resource.description,
                 mime_type=resource.mime_type,
@@ -164,17 +175,20 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
                 tags=list(resource.tags) if resource.tags else None,
                 enabled=resource.enabled,
                 title=resource.title,
+                icons=[icon.model_dump() for icon in resource.icons]
+                if resource.icons
+                else None,
                 meta=resource.meta,
             )
         )
 
     # Extract detailed template information
     template_infos = []
-    for key, template in templates_dict.items():
+    for template in templates_list:
         template_infos.append(
             TemplateInfo(
-                key=key,
-                uri_template=key,  # For v2, key is the URI template
+                key=template.key,
+                uri_template=template.key,
                 name=template.name,
                 description=template.description,
                 mime_type=template.mime_type,
@@ -185,6 +199,9 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
                 tags=list(template.tags) if template.tags else None,
                 enabled=template.enabled,
                 title=template.title,
+                icons=[icon.model_dump() for icon in template.icons]
+                if template.icons
+                else None,
                 meta=template.meta,
             )
         )
@@ -197,13 +214,25 @@ async def inspect_fastmcp_v2(mcp: FastMCP[Any]) -> FastMCPInfo:
         "logging": {},
     }
 
+    # Extract server-level icons and website_url
+    server_icons = (
+        [icon.model_dump() for icon in mcp._mcp_server.icons]
+        if hasattr(mcp._mcp_server, "icons") and mcp._mcp_server.icons
+        else None
+    )
+    server_website_url = (
+        mcp._mcp_server.website_url if hasattr(mcp._mcp_server, "website_url") else None
+    )
+
     return FastMCPInfo(
         name=mcp.name,
         instructions=mcp.instructions,
+        version=(mcp.version if hasattr(mcp, "version") else mcp._mcp_server.version),
+        website_url=server_website_url,
+        icons=server_icons,
         fastmcp_version=fastmcp.__version__,
         mcp_version=importlib.metadata.version("mcp"),
         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,
@@ -248,6 +277,9 @@ async def inspect_fastmcp_v1(mcp: FastMCP1x) -> FastMCPInfo:
                     tags=None,  # v1 doesn't have tags
                     enabled=None,  # v1 doesn't have enabled field
                     title=None,  # v1 doesn't have title
+                    icons=[icon.model_dump() for icon in mcp_tool.icons]
+                    if hasattr(mcp_tool, "icons") and mcp_tool.icons
+                    else None,
                     meta=None,  # v1 doesn't have meta field
                 )
             )
@@ -269,6 +301,9 @@ async def inspect_fastmcp_v1(mcp: FastMCP1x) -> FastMCPInfo:
                     tags=None,  # v1 doesn't have tags
                     enabled=None,  # v1 doesn't have enabled field
                     title=None,  # v1 doesn't have title
+                    icons=[icon.model_dump() for icon in mcp_prompt.icons]
+                    if hasattr(mcp_prompt, "icons") and mcp_prompt.icons
+                    else None,
                     meta=None,  # v1 doesn't have meta field
                 )
             )
@@ -287,6 +322,9 @@ async def inspect_fastmcp_v1(mcp: FastMCP1x) -> FastMCPInfo:
                     tags=None,  # v1 doesn't have tags
                     enabled=None,  # v1 doesn't have enabled field
                     title=None,  # v1 doesn't have title
+                    icons=[icon.model_dump() for icon in mcp_resource.icons]
+                    if hasattr(mcp_resource, "icons") and mcp_resource.icons
+                    else None,
                     meta=None,  # v1 doesn't have meta field
                 )
             )
@@ -306,6 +344,9 @@ async def inspect_fastmcp_v1(mcp: FastMCP1x) -> FastMCPInfo:
                     tags=None,  # v1 doesn't have tags
                     enabled=None,  # v1 doesn't have enabled field
                     title=None,  # v1 doesn't have title
+                    icons=[icon.model_dump() for icon in mcp_template.icons]
+                    if hasattr(mcp_template, "icons") and mcp_template.icons
+                    else None,
                     meta=None,  # v1 doesn't have meta field
                 )
             )
@@ -318,13 +359,26 @@ async def inspect_fastmcp_v1(mcp: FastMCP1x) -> FastMCPInfo:
             "logging": {},
         }
 
+        # Extract server-level icons and website_url from serverInfo
+        server_info = client.initialize_result.serverInfo
+        server_icons = (
+            [icon.model_dump() for icon in server_info.icons]
+            if hasattr(server_info, "icons") and server_info.icons
+            else None
+        )
+        server_website_url = (
+            server_info.websiteUrl if hasattr(server_info, "websiteUrl") else None
+        )
+
         return FastMCPInfo(
             name=mcp._mcp_server.name,
             instructions=mcp._mcp_server.instructions,
+            version=mcp._mcp_server.version,
+            website_url=server_website_url,
+            icons=server_icons,
             fastmcp_version=fastmcp.__version__,  # Version generating this manifest
             mcp_version=importlib.metadata.version("mcp"),
             server_generation=1,  # MCP v1
-            version=mcp._mcp_server.version,
             tools=tool_infos,
             prompts=prompt_infos,
             resources=resource_infos,
@@ -358,7 +412,7 @@ class InspectFormat(str, Enum):
     MCP = "mcp"
 
 
-async def format_fastmcp_info(info: FastMCPInfo) -> bytes:
+def format_fastmcp_info(info: FastMCPInfo) -> bytes:
     """Format FastMCPInfo as FastMCP-specific JSON.
 
     This includes FastMCP-specific fields like tags, enabled, annotations, etc.
@@ -369,6 +423,8 @@ async def format_fastmcp_info(info: FastMCPInfo) -> bytes:
             "name": info.name,
             "instructions": info.instructions,
             "version": info.version,
+            "website_url": info.website_url,
+            "icons": info.icons,
             "generation": info.server_generation,
             "capabilities": info.capabilities,
         },
@@ -445,6 +501,6 @@ async def format_info(
         # This works for both v1 and v2 servers
         if info is None:
             info = await inspect_fastmcp(mcp)
-        return await format_fastmcp_info(info)
+        return format_fastmcp_info(info)
     else:
         raise ValueError(f"Unknown format: {format}")

fastmcp/utilities/json_schema.py

@@ -98,7 +98,7 @@ def _single_pass_optimize(
         if isinstance(node, dict):
             # Collect $ref references for unused definition removal
             if prune_defs:
-                ref = node.get("$ref")
+                ref = node.get("$ref")  # type: ignore
                 if isinstance(ref, str) and ref.startswith("#/$defs/"):
                     referenced_def = ref.split("/")[-1]
                     if current_def_name:
@@ -109,14 +109,31 @@ def _single_pass_optimize(
                         root_refs.add(referenced_def)
 
             # Apply cleanups
+            # Only remove "title" if it's a schema metadata field
+            # Schema objects have keywords like "type", "properties", "$ref", etc.
+            # If we see these, then "title" is metadata, not a property name
             if prune_titles and "title" in node:
-                node.pop("title")
+                # Check if this looks like a schema node
+                if any(
+                    k in node
+                    for k in [
+                        "type",
+                        "properties",
+                        "$ref",
+                        "items",
+                        "allOf",
+                        "oneOf",
+                        "anyOf",
+                        "required",
+                    ]
+                ):
+                    node.pop("title")  # type: ignore
 
             if (
                 prune_additional_properties
-                and node.get("additionalProperties") is False
+                and node.get("additionalProperties") is False  # type: ignore
             ):
-                node.pop("additionalProperties")
+                node.pop("additionalProperties")  # type: ignore
 
             # Recursive traversal
             for key, value in node.items():

fastmcp/utilities/json_schema_type.py

@@ -61,7 +61,7 @@ from pydantic import (
 )
 from typing_extensions import NotRequired, TypedDict
 
-__all__ = ["json_schema_to_type", "JSONSchema"]
+__all__ = ["JSONSchema", "json_schema_to_type"]
 
 
 FORMAT_TYPES: dict[str, Any] = {
@@ -368,7 +368,7 @@ def _schema_to_type(
                 return types[0]
         else:
             if has_null:
-                return Union[tuple(types + [type(None)])]  # type: ignore # noqa: UP007
+                return Union[(*types, type(None))]  # type: ignore
             else:
                 return Union[tuple(types)]  # type: ignore # noqa: UP007
 
@@ -389,7 +389,7 @@ def _schema_to_type(
             if len(types) == 1:
                 return types[0] | None  # type: ignore
             else:
-                return Union[tuple(types + [type(None)])]  # type: ignore # noqa: UP007
+                return Union[(*types, type(None))]  # type: ignore
         return Union[tuple(types)]  # type: ignore # noqa: UP007
 
     return _get_from_type_handler(schema, schemas)(schema)
@@ -578,7 +578,7 @@ def _create_dataclass(
             return _merge_defaults(data, original_schema)
         return data
 
-    setattr(cls, "_apply_defaults", _apply_defaults)
+    cls._apply_defaults = _apply_defaults  # type: ignore[attr-defined]
 
     # Store completed class
     _classes[cache_key] = cls

fastmcp/utilities/logging.py

@@ -1,10 +1,14 @@
 """Logging utilities for FastMCP."""
 
+import contextlib
 import logging
-from typing import Any, Literal
+from typing import Any, Literal, cast
 
 from rich.console import Console
 from rich.logging import RichHandler
+from typing_extensions import override
+
+import fastmcp
 
 
 def get_logger(name: str) -> logging.Logger:
@@ -16,13 +20,16 @@ def get_logger(name: str) -> logging.Logger:
     Returns:
         a configured logger instance
     """
-    return logging.getLogger(f"FastMCP.{name}")
+    if name.startswith("fastmcp."):
+        return logging.getLogger(name=name)
+
+    return logging.getLogger(name=f"fastmcp.{name}")
 
 
 def configure_logging(
     level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | int = "INFO",
     logger: logging.Logger | None = None,
-    enable_rich_tracebacks: bool = True,
+    enable_rich_tracebacks: bool | None = None,
     **rich_kwargs: Any,
 ) -> None:
     """
@@ -33,26 +40,191 @@ def configure_logging(
         level: the log level to use
         rich_kwargs: the parameters to use for creating RichHandler
     """
+    # Check if logging is disabled in settings
+    if not fastmcp.settings.log_enabled:
+        return
+
+    # Use settings default if not specified
+    if enable_rich_tracebacks is None:
+        enable_rich_tracebacks = fastmcp.settings.enable_rich_tracebacks
 
     if logger is None:
-        logger = logging.getLogger("FastMCP")
+        logger = logging.getLogger("fastmcp")
+
+    formatter = logging.Formatter("%(message)s")
+
+    # Don't propagate to the root logger
+    logger.propagate = False
+    logger.setLevel(level)
 
-    # Only configure the FastMCP logger namespace
+    # Configure the handler for normal logs
     handler = RichHandler(
         console=Console(stderr=True),
-        rich_tracebacks=enable_rich_tracebacks,
         **rich_kwargs,
     )
-    formatter = logging.Formatter("%(message)s")
     handler.setFormatter(formatter)
 
-    logger.setLevel(level)
+    # filter to exclude tracebacks
+    handler.addFilter(lambda record: record.exc_info is None)
+
+    # Configure the handler for tracebacks, for tracebacks we use a compressed format:
+    # no path or level name to maximize width available for the traceback
+    # suppress framework frames and limit the number of frames to 3
+
+    import mcp
+    import pydantic
+
+    # Build traceback kwargs with defaults that can be overridden
+    traceback_kwargs = {
+        "console": Console(stderr=True),
+        "show_path": False,
+        "show_level": False,
+        "rich_tracebacks": enable_rich_tracebacks,
+        "tracebacks_max_frames": 3,
+        "tracebacks_suppress": [fastmcp, mcp, pydantic],
+    }
+    # Override defaults with user-provided values
+    traceback_kwargs.update(rich_kwargs)
+
+    traceback_handler = RichHandler(**traceback_kwargs)  # type: ignore[arg-type]
+    traceback_handler.setFormatter(formatter)
+
+    traceback_handler.addFilter(lambda record: record.exc_info is not None)
 
     # Remove any existing handlers to avoid duplicates on reconfiguration
     for hdlr in logger.handlers[:]:
         logger.removeHandler(hdlr)
 
     logger.addHandler(handler)
+    logger.addHandler(traceback_handler)
 
-    # Don't propagate to the root logger
-    logger.propagate = False
+
+@contextlib.contextmanager
+def temporary_log_level(
+    level: str | None,
+    logger: logging.Logger | None = None,
+    enable_rich_tracebacks: bool | None = None,
+    **rich_kwargs: Any,
+):
+    """Context manager to temporarily set log level and restore it afterwards.
+
+    Args:
+        level: The temporary log level to set (e.g., "DEBUG", "INFO")
+        logger: Optional logger to configure (defaults to FastMCP logger)
+        enable_rich_tracebacks: Whether to enable rich tracebacks
+        **rich_kwargs: Additional parameters for RichHandler
+
+    Usage:
+        with temporary_log_level("DEBUG"):
+            # Code that runs with DEBUG logging
+            pass
+        # Original log level is restored here
+    """
+    if level:
+        # Get the original log level from settings
+        original_level = fastmcp.settings.log_level
+
+        # Configure with new level
+        # Cast to proper type for type checker
+        log_level_literal = cast(
+            Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+            level.upper(),
+        )
+        configure_logging(
+            level=log_level_literal,
+            logger=logger,
+            enable_rich_tracebacks=enable_rich_tracebacks,
+            **rich_kwargs,
+        )
+        try:
+            yield
+        finally:
+            # Restore original configuration using configure_logging
+            # This will respect the log_enabled setting
+            configure_logging(
+                level=original_level,
+                logger=logger,
+                enable_rich_tracebacks=enable_rich_tracebacks,
+                **rich_kwargs,
+            )
+    else:
+        yield
+
+
+_level_to_no: dict[
+    Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None, int | None
+] = {
+    "DEBUG": logging.DEBUG,
+    "INFO": logging.INFO,
+    "WARNING": logging.WARNING,
+    "ERROR": logging.ERROR,
+    "CRITICAL": logging.CRITICAL,
+    None: None,
+}
+
+
+class _ClampedLogFilter(logging.Filter):
+    min_level: tuple[int, str] | None
+    max_level: tuple[int, str] | None
+
+    def __init__(
+        self,
+        min_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        | None = None,
+        max_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        | None = None,
+    ):
+        self.min_level = None
+        self.max_level = None
+
+        if min_level_no := _level_to_no.get(min_level):
+            self.min_level = (min_level_no, str(min_level))
+        if max_level_no := _level_to_no.get(max_level):
+            self.max_level = (max_level_no, str(max_level))
+
+        super().__init__()
+
+    @override
+    def filter(self, record: logging.LogRecord) -> bool:
+        if self.max_level:
+            max_level_no, max_level_name = self.max_level
+
+            if record.levelno > max_level_no:
+                record.levelno = max_level_no
+                record.levelname = max_level_name
+                return True
+
+        if self.min_level:
+            min_level_no, min_level_name = self.min_level
+            if record.levelno < min_level_no:
+                record.levelno = min_level_no
+                record.levelname = min_level_name
+                return True
+
+        return True
+
+
+def _clamp_logger(
+    logger: logging.Logger,
+    min_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None = None,
+    max_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None = None,
+) -> None:
+    """Clamp the logger to a minimum and maximum level.
+
+    If min_level is provided, messages logged at a lower level than `min_level` will have their level increased to `min_level`.
+    If max_level is provided, messages logged at a higher level than `max_level` will have their level decreased to `max_level`.
+
+    Args:
+        min_level: The lower bound of the clamp
+        max_level: The upper bound of the clamp
+    """
+    _unclamp_logger(logger=logger)
+
+    logger.addFilter(filter=_ClampedLogFilter(min_level=min_level, max_level=max_level))
+
+
+def _unclamp_logger(logger: logging.Logger) -> None:
+    """Remove all clamped log filters from the logger."""
+    for filter in logger.filters[:]:
+        if isinstance(filter, _ClampedLogFilter):
+            logger.removeFilter(filter)

fastmcp/utilities/mcp_server_config/__init__.py

@@ -15,11 +15,11 @@ 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",
+    "MCPServerConfig",
+    "Source",
+    "UVEnvironment",
     "generate_schema",
 ]

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

@@ -19,7 +19,6 @@ class Environment(BaseModel, ABC):
         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).
@@ -27,4 +26,4 @@ class Environment(BaseModel, ABC):
         Args:
             output_dir: Directory for persistent environment setup
         """
-        pass  # Default no-op implementation
+        # Default no-op implementation