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

fastmcp/tools/tool_transform.py

@@ -1,16 +1,19 @@
 from __future__ import annotations
 
 import inspect
+import warnings
 from collections.abc import Callable
 from contextvars import ContextVar
 from dataclasses import dataclass
-from typing import Annotated, Any, Literal
+from typing import Annotated, Any, Literal, cast
 
+import pydantic_core
 from mcp.types import ToolAnnotations
 from pydantic import ConfigDict
 from pydantic.fields import Field
 from pydantic.functional_validators import BeforeValidator
 
+import fastmcp
 from fastmcp.tools.tool import ParsedFunction, Tool, ToolResult, _convert_to_content
 from fastmcp.utilities.components import _convert_set_default_none
 from fastmcp.utilities.json_schema import compress_schema
@@ -26,7 +29,7 @@ logger = get_logger(__name__)
 
 
 # Context variable to store current transformed tool
-_current_tool: ContextVar[TransformedTool | None] = ContextVar(
+_current_tool: ContextVar[TransformedTool | None] = ContextVar(  # type: ignore[assignment]
     "_current_tool", default=None
 )
 
@@ -312,11 +315,9 @@ class TransformedTool(Tool):
                         # Custom function returns ToolResult - preserve its content
                         return result
                     else:
-                        # Forwarded call with disabled schema - strip structured content
-                        return ToolResult(
-                            content=result.content,
-                            structured_content=None,
-                        )
+                        # Forwarded call with no explicit schema - preserve parent's structured content
+                        # The parent tool may have generated structured content via its own fallback logic
+                        return result
                 elif self.output_schema.get(
                     "type"
                 ) != "object" and not self.output_schema.get("x-fastmcp-wrap-result"):
@@ -334,17 +335,23 @@ class TransformedTool(Tool):
                 result, serializer=self.serializer
             )
 
-            # Handle structured content based on output schema
+            structured_output = None
+            # First handle structured content based on output schema, if any
             if self.output_schema is not None:
                 if self.output_schema.get("x-fastmcp-wrap-result"):
                     # Schema says wrap - always wrap in result key
                     structured_output = {"result": result}
                 else:
-                    # Object schemas - use result directly
-                    # User is responsible for returning dict-compatible data
                     structured_output = result
-            else:
-                structured_output = None
+            # If no output schema, try to serialize the result. If it is a dict, use
+            # it as structured content. If it is not a dict, ignore it.
+            if structured_output is None:
+                try:
+                    structured_output = pydantic_core.to_jsonable_python(result)
+                    if not isinstance(structured_output, dict):
+                        structured_output = None
+                except Exception:
+                    pass
 
             return ToolResult(
                 content=unstructured_result,
@@ -363,9 +370,9 @@ class TransformedTool(Tool):
         tags: set[str] | None = None,
         transform_fn: Callable[..., Any] | None = None,
         transform_args: dict[str, ArgTransform] | None = None,
-        annotations: ToolAnnotations | None = None,
-        output_schema: dict[str, Any] | None | Literal[False] = None,
-        serializer: Callable[[Any], str] | None = None,
+        annotations: ToolAnnotations | None | NotSetT = NotSet,
+        output_schema: dict[str, Any] | None | NotSetT | Literal[False] = NotSet,
+        serializer: Callable[[Any], str] | None | NotSetT = NotSet,
         meta: dict[str, Any] | None | NotSetT = NotSet,
         enabled: bool | None = None,
     ) -> TransformedTool:
@@ -432,7 +439,7 @@ class TransformedTool(Tool):
             })
 
             # Disable structured outputs
-            Tool.from_tool(parent, output_schema=False)
+            Tool.from_tool(parent, output_schema=None)
 
             # Return ToolResult for full control
             async def custom_output(**kwargs) -> ToolResult:
@@ -445,6 +452,11 @@ class TransformedTool(Tool):
         """
         transform_args = transform_args or {}
 
+        if transform_fn is not None:
+            parsed_fn = ParsedFunction.from_function(transform_fn, validate=False)
+        else:
+            parsed_fn = None
+
         # Validate transform_args
         parent_params = set(tool.parameters.get("properties", {}).keys())
         unknown_args = set(transform_args.keys()) - parent_params
@@ -457,17 +469,12 @@ class TransformedTool(Tool):
         # Always create the forwarding transform
         schema, forwarding_fn = cls._create_forwarding_transform(tool, transform_args)
 
-        # Handle output schema with smart fallback
-        if output_schema is False:
-            final_output_schema = None
-        elif output_schema is not None:
-            # Explicit schema provided - use as-is
-            final_output_schema = output_schema
-        else:
-            # Smart fallback: try custom function, then parent, then None
+        # Handle output schema
+        if output_schema is NotSet:
+            # Use smart fallback: try custom function, then parent
             if transform_fn is not None:
-                parsed_fn = ParsedFunction.from_function(transform_fn, validate=False)
-                final_output_schema = parsed_fn.output_schema
+                # parsed fn is not none here
+                final_output_schema = cast(ParsedFunction, parsed_fn).output_schema
                 if final_output_schema is None:
                     # Check if function returns ToolResult - if so, don't fall back to parent
                     return_annotation = inspect.signature(
@@ -479,15 +486,26 @@ class TransformedTool(Tool):
                         final_output_schema = tool.output_schema
             else:
                 final_output_schema = tool.output_schema
+        elif output_schema is False:
+            # Handle False as deprecated synonym for None (deprecated in 2.11.4)
+            if fastmcp.settings.deprecation_warnings:
+                warnings.warn(
+                    "Passing output_schema=False is deprecated. Use output_schema=None instead.",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+            final_output_schema = None
+        else:
+            final_output_schema = cast(dict | None, output_schema)
 
         if transform_fn is None:
             # User wants pure transformation - use forwarding_fn as the main function
             final_fn = forwarding_fn
             final_schema = schema
         else:
+            # parsed fn is not none here
+            parsed_fn = cast(ParsedFunction, parsed_fn)
             # User provided custom function - merge schemas
-            if "parsed_fn" not in locals():
-                parsed_fn = ParsedFunction.from_function(transform_fn, validate=False)
             final_fn = transform_fn
 
             has_kwargs = cls._function_has_kwargs(transform_fn)
@@ -552,6 +570,13 @@ class TransformedTool(Tool):
         )
         final_title = title if not isinstance(title, NotSetT) else tool.title
         final_meta = meta if not isinstance(meta, NotSetT) else tool.meta
+        final_annotations = (
+            annotations if not isinstance(annotations, NotSetT) else tool.annotations
+        )
+        final_serializer = (
+            serializer if not isinstance(serializer, NotSetT) else tool.serializer
+        )
+        final_enabled = enabled if enabled is not None else tool.enabled
 
         transformed_tool = cls(
             fn=final_fn,
@@ -563,11 +588,11 @@ class TransformedTool(Tool):
             parameters=final_schema,
             output_schema=final_output_schema,
             tags=tags or tool.tags,
-            annotations=annotations or tool.annotations,
-            serializer=serializer or tool.serializer,
+            annotations=final_annotations,
+            serializer=final_serializer,
             meta=final_meta,
             transform_args=transform_args,
-            enabled=enabled if enabled is not None else True,
+            enabled=final_enabled,
         )
 
         return transformed_tool
@@ -816,12 +841,30 @@ class TransformedTool(Tool):
             if "default" in param_schema:
                 final_required.discard(param_name)
 
-        return {
+        # Merge $defs from both schemas, with override taking precedence
+        merged_defs = base_schema.get("$defs", {}).copy()
+        override_defs = override_schema.get("$defs", {})
+
+        for def_name, def_schema in override_defs.items():
+            if def_name in merged_defs:
+                base_def = merged_defs[def_name].copy()
+                base_def.update(def_schema)
+                merged_defs[def_name] = base_def
+            else:
+                merged_defs[def_name] = def_schema.copy()
+
+        result = {
             "type": "object",
             "properties": merged_props,
             "required": list(final_required),
         }
 
+        if merged_defs:
+            result["$defs"] = merged_defs
+            result = compress_schema(result, prune_defs=True)
+
+        return result
+
     @staticmethod
     def _function_has_kwargs(fn: Callable[..., Any]) -> bool:
         """Check if function accepts **kwargs.

fastmcp/utilities/auth.py

@@ -0,0 +1,34 @@
+"""Authentication utility helpers."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+def parse_scopes(value: Any) -> list[str] | None:
+    """Parse scopes from environment variables or settings values.
+
+    Accepts either a JSON array string, a comma- or space-separated string,
+    a list of strings, or ``None``. Returns a list of scopes or ``None`` if
+    no value is provided.
+    """
+    if value is None or value == "":
+        return None if value is None else []
+    if isinstance(value, list):
+        return [str(v).strip() for v in value if str(v).strip()]
+    if isinstance(value, str):
+        value = value.strip()
+        if not value:
+            return []
+        # Try JSON array first
+        if value.startswith("["):
+            try:
+                data = json.loads(value)
+                if isinstance(data, list):
+                    return [str(v).strip() for v in data if str(v).strip()]
+            except Exception:
+                pass
+        # Fallback to comma/space separated list
+        return [s.strip() for s in value.replace(",", " ").split() if s.strip()]
+    return value

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

@@ -91,18 +91,34 @@ class FastMCPComponent(FastMCPBaseModel):
 
         return meta or None
 
-    def with_key(self, key: str) -> Self:
+    def model_copy(
+        self,
+        *,
+        update: dict[str, Any] | None = None,
+        deep: bool = False,
+        key: str | None = None,
+    ) -> Self:
+        """
+        Create a copy of the component.
+
+        Args:
+            update: A dictionary of fields to update.
+            deep: Whether to deep copy the component.
+            key: The key to use for the copy.
+        """
         # `model_copy` has an `update` parameter but it doesn't work for certain private attributes
         # https://github.com/pydantic/pydantic/issues/12116
-        # So we manually set the private attribute here instead
-        copy = self.model_copy()
-        copy._key = key
+        # So we manually set the private attribute here instead, such as _key
+        copy = super().model_copy(update=update, deep=deep)
+        if key is not None:
+            copy._key = key
         return copy
 
     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: