fastmcp 2.12.2__py3-none-any.whl → 2.12.4__py3-none-any.whl

fastmcp/server/server.py

@@ -8,11 +8,7 @@ import re
 import secrets
 import warnings
 from collections.abc import AsyncIterator, Awaitable, Callable
-from contextlib import (
-    AbstractAsyncContextManager,
-    AsyncExitStack,
-    asynccontextmanager,
-)
+from contextlib import AbstractAsyncContextManager, AsyncExitStack, asynccontextmanager
 from dataclasses import dataclass
 from functools import partial
 from pathlib import Path
@@ -65,7 +61,7 @@ from fastmcp.tools.tool import FunctionTool, Tool, ToolResult
 from fastmcp.tools.tool_transform import ToolTransformConfig
 from fastmcp.utilities.cli import log_server_banner
 from fastmcp.utilities.components import FastMCPComponent
-from fastmcp.utilities.logging import get_logger
+from fastmcp.utilities.logging import get_logger, temporary_log_level
 from fastmcp.utilities.types import NotSet, NotSetT
 
 if TYPE_CHECKING:
@@ -208,8 +204,8 @@ class FastMCP(Generic[LifespanResultT]):
         # if auth is `NotSet`, try to create a provider from the environment
         if auth is NotSet:
             if fastmcp.settings.server_auth is not None:
-                # ImportString returns the class itself
-                auth = fastmcp.settings.server_auth()
+                # server_auth_class returns the class itself
+                auth = fastmcp.settings.server_auth_class()
             else:
                 auth = None
         self.auth = cast(AuthProvider | None, auth)
@@ -329,6 +325,10 @@ class FastMCP(Generic[LifespanResultT]):
     def instructions(self) -> str | None:
         return self._mcp_server.instructions
 
+    @instructions.setter
+    def instructions(self, value: str | None) -> None:
+        self._mcp_server.instructions = value
+
     @property
     def version(self) -> str | None:
         return self._mcp_server.version
@@ -812,6 +812,8 @@ class FastMCP(Generic[LifespanResultT]):
 
         Delegates to _get_prompt, which should be overridden by FastMCP subclasses.
         """
+        import fastmcp.server.context
+
         logger.debug(
             f"[{self.name}] Handler called: get_prompt %s with %s", name, arguments
         )
@@ -1208,8 +1210,8 @@ class FastMCP(Generic[LifespanResultT]):
                 return f"Weather for {city}"
 
             @server.resource("resource://{city}/weather")
-            def get_weather_with_context(city: str, ctx: Context) -> str:
-                ctx.info(f"Fetching weather for {city}")
+            async def get_weather_with_context(city: str, ctx: Context) -> str:
+                await ctx.info(f"Fetching weather for {city}")
                 return f"Weather for {city}"
 
             @server.resource("resource://{city}/weather")
@@ -1384,8 +1386,8 @@ class FastMCP(Generic[LifespanResultT]):
                 ]
 
             @server.prompt()
-            def analyze_with_context(table_name: str, ctx: Context) -> list[Message]:
-                ctx.info(f"Analyzing table {table_name}")
+            async def analyze_with_context(table_name: str, ctx: Context) -> list[Message]:
+                await ctx.info(f"Analyzing table {table_name}")
                 schema = read_table_schema(table_name)
                 return [
                     {
@@ -1395,7 +1397,7 @@ class FastMCP(Generic[LifespanResultT]):
                 ]
 
             @server.prompt("custom_name")
-            def analyze_file(path: str) -> list[Message]:
+            async def analyze_file(path: str) -> list[Message]:
                 content = await read_file(path)
                 return [
                     {
@@ -1479,9 +1481,15 @@ class FastMCP(Generic[LifespanResultT]):
             meta=meta,
         )
 
-    async def run_stdio_async(self, show_banner: bool = True) -> None:
-        """Run the server using stdio transport."""
+    async def run_stdio_async(
+        self, show_banner: bool = True, log_level: str | None = None
+    ) -> None:
+        """Run the server using stdio transport.
 
+        Args:
+            show_banner: Whether to display the server banner
+            log_level: Log level for the server
+        """
         # Display server banner
         if show_banner:
             log_server_banner(
@@ -1489,15 +1497,16 @@ class FastMCP(Generic[LifespanResultT]):
                 transport="stdio",
             )
 
-        async with stdio_server() as (read_stream, write_stream):
-            logger.info(f"Starting MCP server {self.name!r} with transport 'stdio'")
-            await self._mcp_server.run(
-                read_stream,
-                write_stream,
-                self._mcp_server.create_initialization_options(
-                    NotificationOptions(tools_changed=True)
-                ),
-            )
+        with temporary_log_level(log_level):
+            async with stdio_server() as (read_stream, write_stream):
+                logger.info(f"Starting MCP server {self.name!r} with transport 'stdio'")
+                await self._mcp_server.run(
+                    read_stream,
+                    write_stream,
+                    self._mcp_server.create_initialization_options(
+                        NotificationOptions(tools_changed=True)
+                    ),
+                )
 
     async def run_http_async(
         self,
@@ -1523,7 +1532,6 @@ class FastMCP(Generic[LifespanResultT]):
             middleware: A list of middleware to apply to the app
             stateless_http: Whether to use stateless HTTP (defaults to settings.stateless_http)
         """
-
         host = host or self._deprecated_settings.host
         port = port or self._deprecated_settings.port
         default_log_level_to_use = (
@@ -1564,14 +1572,15 @@ class FastMCP(Generic[LifespanResultT]):
         if "log_config" not in config_kwargs and "log_level" not in config_kwargs:
             config_kwargs["log_level"] = default_log_level_to_use
 
-        config = uvicorn.Config(app, host=host, port=port, **config_kwargs)
-        server = uvicorn.Server(config)
-        path = app.state.path.lstrip("/")  # type: ignore
-        logger.info(
-            f"Starting MCP server {self.name!r} with transport {transport!r} on http://{host}:{port}/{path}"
-        )
+        with temporary_log_level(log_level):
+            config = uvicorn.Config(app, host=host, port=port, **config_kwargs)
+            server = uvicorn.Server(config)
+            path = app.state.path.lstrip("/")  # type: ignore
+            logger.info(
+                f"Starting MCP server {self.name!r} with transport {transport!r} on http://{host}:{port}/{path}"
+            )
 
-        await server.serve()
+            await server.serve()
 
     async def run_sse_async(
         self,
@@ -2120,10 +2129,8 @@ class FastMCP(Generic[LifespanResultT]):
             # - Connected clients: reuse existing session for all requests
             # - Disconnected clients: create fresh sessions per request for isolation
             if client.is_connected():
-                from fastmcp.utilities.logging import get_logger
-
-                logger = get_logger(__name__)
-                logger.info(
+                _proxy_logger = get_logger(__name__)
+                _proxy_logger.info(
                     "Proxy detected connected client - reusing existing session for all requests. "
                     "This may cause context mixing in concurrent scenarios."
                 )

fastmcp/settings.py

@@ -3,7 +3,7 @@ from __future__ import annotations as _annotations
 import inspect
 import warnings
 from pathlib import Path
-from typing import Annotated, Any, Literal
+from typing import TYPE_CHECKING, Annotated, Any, Literal
 
 from pydantic import Field, ImportString, field_validator
 from pydantic.fields import FieldInfo
@@ -23,6 +23,9 @@ LOG_LEVEL = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
 
 DuplicateBehavior = Literal["warn", "error", "replace", "ignore"]
 
+if TYPE_CHECKING:
+    from fastmcp.server.auth.auth import AuthProvider
+
 
 class ExtendedEnvSettingsSource(EnvSettingsSource):
     """
@@ -258,7 +261,7 @@ class Settings(BaseSettings):
 
     # Auth settings
     server_auth: Annotated[
-        ImportString | None,
+        str | None,
         Field(
             description=inspect.cleandoc(
                 """
@@ -266,13 +269,13 @@ class Settings(BaseSettings):
                 the full module path to an AuthProvider class (e.g., 
                 'fastmcp.server.auth.providers.google.GoogleProvider').
 
-                The specified class will be imported and instantiated automatically.
-                Any class that inherits from AuthProvider can be used, including
-                custom implementations.
+                The specified class will be imported and instantiated automatically
+                during FastMCP server creation. Any class that inherits from AuthProvider
+                can be used, including custom implementations.
 
                 If None, no automatic configuration will take place.
 
-                This setting is *always* overriden by any auth provider passed to the
+                This setting is *always* overridden by any auth provider passed to the
                 FastMCP constructor.
 
                 Note that most auth providers require additional configuration
@@ -343,6 +346,39 @@ class Settings(BaseSettings):
         ),
     ] = False
 
+    show_cli_banner: Annotated[
+        bool,
+        Field(
+            default=True,
+            description=inspect.cleandoc(
+                """
+                If True, the server banner will be displayed when running the server via CLI.
+                This setting can be overridden by the --no-banner CLI flag.
+                Set to False via FASTMCP_SHOW_CLI_BANNER=false to suppress the banner.
+                """
+            ),
+        ),
+    ] = True
+
+    @property
+    def server_auth_class(self) -> AuthProvider | None:
+        from fastmcp.utilities.types import get_cached_typeadapter
+
+        if not self.server_auth:
+            return None
+
+        # https://github.com/jlowin/fastmcp/issues/1749
+        # Pydantic imports the module in an ImportString during model validation, but we don't want the server
+        # auth module imported during settings creation as it imports dependencies we aren't ready for yet.
+        # To fix this while limiting breaking changes, we delay the import by only creating the ImportString
+        # when the class is actually needed
+
+        type_adapter = get_cached_typeadapter(ImportString)
+
+        auth_class = type_adapter.validate_python(self.server_auth)
+
+        return auth_class
+
 
 def __getattr__(name: str):
     """

fastmcp/tools/tool.py

@@ -10,6 +10,7 @@ from typing import (
     Any,
     Generic,
     Literal,
+    TypeAlias,
     get_type_hints,
 )
 
@@ -55,6 +56,9 @@ class _UnserializableType:
     pass
 
 
+ToolResultSerializerType: TypeAlias = Callable[[Any], str]
+
+
 def default_serializer(data: Any) -> str:
     return pydantic_core.to_json(data, fallback=str).decode()
 
@@ -70,12 +74,12 @@ class ToolResult:
         elif content is None:
             content = structured_content
 
-        self.content = _convert_to_content(content)
+        self.content: list[ContentBlock] = _convert_to_content(result=content)
 
         if structured_content is not None:
             try:
                 structured_content = pydantic_core.to_jsonable_python(
-                    structured_content
+                    value=structured_content
                 )
             except pydantic_core.PydanticSerializationError as e:
                 logger.error(
@@ -112,7 +116,7 @@ class Tool(FastMCPComponent):
         Field(description="Additional annotations about the tool"),
     ] = None
     serializer: Annotated[
-        Callable[[Any], str] | None,
+        ToolResultSerializerType | None,
         Field(description="Optional custom serializer for tool results"),
     ] = None
 
@@ -138,23 +142,25 @@ class Tool(FastMCPComponent):
         include_fastmcp_meta: bool | None = None,
         **overrides: Any,
     ) -> MCPTool:
+        """Convert the FastMCP tool to an MCP tool."""
+        title = None
+
         if self.title:
             title = self.title
         elif self.annotations and self.annotations.title:
             title = self.annotations.title
-        else:
-            title = None
-
-        kwargs = {
-            "name": self.name,
-            "description": self.description,
-            "inputSchema": self.parameters,
-            "outputSchema": self.output_schema,
-            "annotations": self.annotations,
-            "title": title,
-            "_meta": self.get_meta(include_fastmcp_meta=include_fastmcp_meta),
-        }
-        return MCPTool(**kwargs | overrides)
+
+        return MCPTool(
+            name=overrides.get("name", self.name),
+            title=overrides.get("title", title),
+            description=overrides.get("description", self.description),
+            inputSchema=overrides.get("inputSchema", self.parameters),
+            outputSchema=overrides.get("outputSchema", self.output_schema),
+            annotations=overrides.get("annotations", self.annotations),
+            _meta=overrides.get(
+                "_meta", self.get_meta(include_fastmcp_meta=include_fastmcp_meta)
+            ),
+        )
 
     @staticmethod
     def from_function(
@@ -166,7 +172,7 @@ class Tool(FastMCPComponent):
         annotations: ToolAnnotations | None = None,
         exclude_args: list[str] | None = None,
         output_schema: dict[str, Any] | None | NotSetT | Literal[False] = NotSet,
-        serializer: Callable[[Any], str] | None = None,
+        serializer: ToolResultSerializerType | None = None,
         meta: dict[str, Any] | None = None,
         enabled: bool | None = None,
     ) -> FunctionTool:
@@ -208,7 +214,7 @@ class Tool(FastMCPComponent):
         tags: set[str] | None = None,
         annotations: ToolAnnotations | None | NotSetT = NotSet,
         output_schema: dict[str, Any] | None | NotSetT | Literal[False] = NotSet,
-        serializer: Callable[[Any], str] | None = None,
+        serializer: ToolResultSerializerType | None = None,
         meta: dict[str, Any] | None | NotSetT = NotSet,
         transform_args: dict[str, ArgTransform] | None = None,
         enabled: bool | None = None,
@@ -246,7 +252,7 @@ class FunctionTool(Tool):
         annotations: ToolAnnotations | None = None,
         exclude_args: list[str] | None = None,
         output_schema: dict[str, Any] | None | NotSetT | Literal[False] = NotSet,
-        serializer: Callable[[Any], str] | None = None,
+        serializer: ToolResultSerializerType | None = None,
         meta: dict[str, Any] | None = None,
         enabled: bool | None = None,
     ) -> FunctionTool:
@@ -315,27 +321,33 @@ class FunctionTool(Tool):
 
         unstructured_result = _convert_to_content(result, serializer=self.serializer)
 
-        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:
-                structured_output = result
-        # 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:
+        if self.output_schema is None:
+            # Do not produce a structured output for MCP Content Types
+            if isinstance(result, ContentBlock | Audio | Image | File) or (
+                isinstance(result, list | tuple)
+                and any(isinstance(item, ContentBlock) for item in result)
+            ):
+                return ToolResult(content=unstructured_result)
+
+            # Otherwise, try to serialize the result as a dict
             try:
-                structured_output = pydantic_core.to_jsonable_python(result)
-                if not isinstance(structured_output, dict):
-                    structured_output = None
-            except Exception:
+                structured_content = pydantic_core.to_jsonable_python(result)
+                if isinstance(structured_content, dict):
+                    return ToolResult(
+                        content=unstructured_result,
+                        structured_content=structured_content,
+                    )
+
+            except pydantic_core.PydanticSerializationError:
                 pass
 
+            return ToolResult(content=unstructured_result)
+
+        wrap_result = self.output_schema.get("x-fastmcp-wrap-result")
+
         return ToolResult(
             content=unstructured_result,
-            structured_content=structured_output,
+            structured_content={"result": result} if wrap_result else result,
         )
 
 
@@ -401,7 +413,9 @@ class ParsedFunction:
 
         input_type_adapter = get_cached_typeadapter(fn)
         input_schema = input_type_adapter.json_schema()
-        input_schema = compress_schema(input_schema, prune_params=prune_params)
+        input_schema = compress_schema(
+            input_schema, prune_params=prune_params, prune_titles=True
+        )
 
         output_schema = None
         # Get the return annotation from the signature
@@ -461,7 +475,7 @@ class ParsedFunction:
                 else:
                     output_schema = base_schema
 
-                output_schema = compress_schema(output_schema)
+                output_schema = compress_schema(output_schema, prune_titles=True)
 
             except PydanticSchemaGenerationError as e:
                 if "_UnserializableType" not in str(e):
@@ -476,65 +490,69 @@ class ParsedFunction:
         )
 
 
-def _convert_to_content(
-    result: Any,
-    serializer: Callable[[Any], str] | None = None,
-    _process_as_single_item: bool = False,
-) -> list[ContentBlock]:
-    """Convert a result to a sequence of content objects."""
+def _serialize_with_fallback(
+    result: Any, serializer: ToolResultSerializerType | None = None
+) -> str:
+    if serializer is not None:
+        try:
+            return serializer(result)
+        except Exception as e:
+            logger.warning(
+                "Error serializing tool result: %s",
+                e,
+                exc_info=True,
+            )
 
-    if result is None:
-        return []
+    return default_serializer(result)
 
-    if isinstance(result, ContentBlock):
-        return [result]
 
-    if isinstance(result, Image):
-        return [result.to_image_content()]
+def _convert_to_single_content_block(
+    item: Any,
+    serializer: ToolResultSerializerType | None = None,
+) -> ContentBlock:
+    if isinstance(item, ContentBlock):
+        return item
 
-    elif isinstance(result, Audio):
-        return [result.to_audio_content()]
+    if isinstance(item, Image):
+        return item.to_image_content()
 
-    elif isinstance(result, File):
-        return [result.to_resource_content()]
+    if isinstance(item, Audio):
+        return item.to_audio_content()
 
-    if isinstance(result, list | tuple) and not _process_as_single_item:
-        # if the result is a list, then it could either be a list of MCP types,
-        # or a "regular" list that the tool is returning, or a mix of both.
-        #
-        # so we extract all the MCP types / images and convert them as individual content elements,
-        # and aggregate the rest as a single content element
+    if isinstance(item, File):
+        return item.to_resource_content()
 
-        mcp_types = []
-        other_content = []
+    if isinstance(item, str):
+        return TextContent(type="text", text=item)
 
-        for item in result:
-            if isinstance(item, ContentBlock | Image | Audio | File):
-                mcp_types.append(_convert_to_content(item)[0])
-            else:
-                other_content.append(item)
+    return TextContent(type="text", text=_serialize_with_fallback(item, serializer))
 
-        if other_content:
-            other_content = _convert_to_content(
-                other_content,
-                serializer=serializer,
-                _process_as_single_item=True,
-            )
 
-        return other_content + mcp_types
+def _convert_to_content(
+    result: Any,
+    serializer: ToolResultSerializerType | None = None,
+) -> list[ContentBlock]:
+    """Convert a result to a sequence of content objects."""
 
-    if not isinstance(result, str):
-        if serializer is None:
-            result = default_serializer(result)
-        else:
-            try:
-                result = serializer(result)
-            except Exception as e:
-                logger.warning(
-                    "Error serializing tool result: %s",
-                    e,
-                    exc_info=True,
-                )
-                result = default_serializer(result)
+    if result is None:
+        return []
 
-    return [TextContent(type="text", text=result)]
+    if not isinstance(result, (list | tuple)):
+        return [_convert_to_single_content_block(result, serializer)]
+
+    # If all items are ContentBlocks, return them as is
+    if all(isinstance(item, ContentBlock) for item in result):
+        return result
+
+    # If any item is a ContentBlock, convert non-ContentBlock items to TextContent
+    # without aggregating them
+    if any(isinstance(item, ContentBlock) for item in result):
+        return [
+            _convert_to_single_content_block(item, serializer)
+            if not isinstance(item, ContentBlock)
+            else item
+            for item in result
+        ]
+
+    # If none of the items are ContentBlocks, aggregate all items into a single TextContent
+    return [TextContent(type="text", text=_serialize_with_fallback(result, serializer))]

fastmcp/tools/tool_transform.py

@@ -934,7 +934,7 @@ def apply_transformations_to_tools(
     tools: dict[str, Tool],
     transformations: dict[str, ToolTransformConfig],
 ) -> dict[str, Tool]:
-    """Apply a list of transformations to a list of tools. Tools that do not have any transforamtions
+    """Apply a list of transformations to a list of tools. Tools that do not have any transformations
     are left unchanged.
     """
 

fastmcp/utilities/json_schema.py

@@ -109,8 +109,25 @@ 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")
 
             if (
                 prune_additional_properties