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

fastmcp/experimental/utilities/openapi/schemas.py

@@ -79,6 +79,7 @@ def _replace_ref_with_defs(
 
     Examples:
     - {"type": "object", "properties": {"$ref": "#/components/schemas/..."}}
+    - {"type": "object", "additionalProperties": {"$ref": "#/components/schemas/..."}, "properties": {...}}
     - {"$ref": "#/components/schemas/..."}
     - {"items": {"$ref": "#/components/schemas/..."}}
     - {"anyOf": [{"$ref": "#/components/schemas/..."}]}
@@ -117,6 +118,11 @@ def _replace_ref_with_defs(
     for section in ["anyOf", "allOf", "oneOf"]:
         for i, item in enumerate(schema.get(section, [])):
             schema[section][i] = _replace_ref_with_defs(item)
+    if additionalProperties := schema.get("additionalProperties"):
+        if not isinstance(additionalProperties, bool):
+            schema["additionalProperties"] = _replace_ref_with_defs(
+                additionalProperties
+            )
     if info.get("description", description) and not schema.get("description"):
         schema["description"] = description
     return schema
@@ -297,9 +303,11 @@ def _combine_schemas_and_map_params(
 
             # Convert refs if needed
             if convert_refs:
-                param_schema = _replace_ref_with_defs(param.schema_)
+                param_schema = _replace_ref_with_defs(param.schema_, param.description)
             else:
-                param_schema = param.schema_
+                param_schema = param.schema_.copy()
+                if param.description and not param_schema.get("description"):
+                    param_schema["description"] = param.description
             original_desc = param_schema.get("description", "")
             location_desc = f"({param.location.capitalize()} parameter)"
             if original_desc:
@@ -324,9 +332,11 @@ def _combine_schemas_and_map_params(
 
             # Convert refs if needed
             if convert_refs:
-                param_schema = _replace_ref_with_defs(param.schema_)
+                param_schema = _replace_ref_with_defs(param.schema_, param.description)
             else:
-                param_schema = param.schema_
+                param_schema = param.schema_.copy()
+                if param.description and not param_schema.get("description"):
+                    param_schema["description"] = param.description
 
             # Don't make optional parameters nullable - they can simply be omitted
             # The OpenAPI specification doesn't require optional parameters to accept null values
@@ -344,7 +354,7 @@ def _combine_schemas_and_map_params(
             if route.request_body.required:
                 required.append("body")
             parameter_map["body"] = {"location": "body", "openapi_name": "body"}
-        else:
+        elif body_props:
             # Normal case: body has properties
             for prop_name, prop_schema in body_props.items():
                 properties[prop_name] = prop_schema
@@ -357,6 +367,22 @@ def _combine_schemas_and_map_params(
 
             if route.request_body.required:
                 required.extend(body_schema.get("required", []))
+        else:
+            # Handle direct array/primitive schemas (like list[str] parameters from FastAPI)
+            # Use the schema title as parameter name, fall back to generic name
+            param_name = body_schema.get("title", "body").lower()
+
+            # Clean the parameter name to be valid
+            import re
+
+            param_name = re.sub(r"[^a-zA-Z0-9_]", "_", param_name)
+            if not param_name or param_name[0].isdigit():
+                param_name = "body_data"
+
+            properties[param_name] = body_schema
+            if route.request_body.required:
+                required.append(param_name)
+            parameter_map[param_name] = {"location": "body", "openapi_name": param_name}
 
     result = {
         "type": "object",
@@ -559,9 +585,9 @@ def extract_output_schema_from_responses(
 
 # Export public symbols
 __all__ = [
-    "clean_schema_for_display",
     "_combine_schemas",
     "_combine_schemas_and_map_params",
-    "extract_output_schema_from_responses",
     "_make_optional_parameter_nullable",
+    "clean_schema_for_display",
+    "extract_output_schema_from_responses",
 ]

fastmcp/mcp_config.py

@@ -101,7 +101,7 @@ class _TransformingMCPServerMixin(FastMCPBaseModel):
             ClientTransport,  # pyright: ignore[reportUnusedImport]
         )
 
-        transport: ClientTransport = super().to_transport()  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue, reportUnknownVariableType]
+        transport: ClientTransport = super().to_transport()  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue, reportUnknownVariableType]  # ty: ignore[unresolved-attribute]
         transport = cast(ClientTransport, transport)
 
         client: Client[ClientTransport] = Client(transport=transport, name=client_name)
@@ -288,9 +288,8 @@ class MCPConfig(BaseModel):
     @classmethod
     def from_file(cls, file_path: Path) -> Self:
         """Load configuration from JSON file."""
-        if file_path.exists():
-            if content := file_path.read_text().strip():
-                return cls.model_validate_json(content)
+        if file_path.exists() and (content := file_path.read_text().strip()):
+            return cls.model_validate_json(content)
 
         raise ValueError(f"No MCP servers defined in the config: {file_path}")
 

fastmcp/prompts/__init__.py

@@ -2,8 +2,8 @@ from .prompt import Prompt, PromptMessage, Message
 from .prompt_manager import PromptManager
 
 __all__ = [
+    "Message",
     "Prompt",
     "PromptManager",
     "PromptMessage",
-    "Message",
 ]

fastmcp/prompts/prompt.py

@@ -4,12 +4,11 @@ from __future__ import annotations as _annotations
 
 import inspect
 import json
-from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable, Sequence
 from typing import Any
 
 import pydantic_core
-from mcp.types import ContentBlock, PromptMessage, Role, TextContent
+from mcp.types import ContentBlock, Icon, PromptMessage, Role, TextContent
 from mcp.types import Prompt as MCPPrompt
 from mcp.types import PromptArgument as MCPPromptArgument
 from pydantic import Field, TypeAdapter
@@ -62,7 +61,7 @@ class PromptArgument(FastMCPBaseModel):
     )
 
 
-class Prompt(FastMCPComponent, ABC):
+class Prompt(FastMCPComponent):
     """A prompt template that can be rendered with parameters."""
 
     arguments: list[PromptArgument] | None = Field(
@@ -100,14 +99,17 @@ class Prompt(FastMCPComponent, ABC):
             )
             for arg in self.arguments or []
         ]
-        kwargs = {
-            "name": self.name,
-            "description": self.description,
-            "arguments": arguments,
-            "title": self.title,
-            "_meta": self.get_meta(include_fastmcp_meta=include_fastmcp_meta),
-        }
-        return MCPPrompt(**kwargs | overrides)
+
+        return MCPPrompt(
+            name=overrides.get("name", self.name),
+            description=overrides.get("description", self.description),
+            arguments=arguments,
+            title=overrides.get("title", self.title),
+            icons=overrides.get("icons", self.icons),
+            _meta=overrides.get(
+                "_meta", self.get_meta(include_fastmcp_meta=include_fastmcp_meta)
+            ),
+        )
 
     @staticmethod
     def from_function(
@@ -115,6 +117,7 @@ class Prompt(FastMCPComponent, ABC):
         name: str | None = None,
         title: str | None = None,
         description: str | None = None,
+        icons: list[Icon] | None = None,
         tags: set[str] | None = None,
         enabled: bool | None = None,
         meta: dict[str, Any] | None = None,
@@ -132,18 +135,22 @@ class Prompt(FastMCPComponent, ABC):
             name=name,
             title=title,
             description=description,
+            icons=icons,
             tags=tags,
             enabled=enabled,
             meta=meta,
         )
 
-    @abstractmethod
     async def render(
         self,
         arguments: dict[str, Any] | None = None,
     ) -> list[PromptMessage]:
-        """Render the prompt with arguments."""
-        raise NotImplementedError("Prompt.render() must be implemented by subclasses")
+        """Render the prompt with arguments.
+
+        This method is not implemented in the base Prompt class and must be
+        implemented by subclasses.
+        """
+        raise NotImplementedError("Subclasses must implement render()")
 
 
 class FunctionPrompt(Prompt):
@@ -158,6 +165,7 @@ class FunctionPrompt(Prompt):
         name: str | None = None,
         title: str | None = None,
         description: str | None = None,
+        icons: list[Icon] | None = None,
         tags: set[str] | None = None,
         enabled: bool | None = None,
         meta: dict[str, Any] | None = None,
@@ -199,10 +207,7 @@ class FunctionPrompt(Prompt):
         # Auto-detect context parameter if not provided
 
         context_kwarg = find_kwarg_by_type(fn, kwarg_type=Context)
-        if context_kwarg:
-            prune_params = [context_kwarg]
-        else:
-            prune_params = None
+        prune_params = [context_kwarg] if context_kwarg else None
 
         parameters = compress_schema(parameters, prune_params=prune_params)
 
@@ -251,6 +256,7 @@ class FunctionPrompt(Prompt):
             name=func_name,
             title=title,
             description=description,
+            icons=icons,
             arguments=arguments,
             tags=tags or set(),
             enabled=enabled if enabled is not None else True,
@@ -281,10 +287,7 @@ class FunctionPrompt(Prompt):
                 if (
                     param.annotation == inspect.Parameter.empty
                     or param.annotation is str
-                ):
-                    converted_kwargs[param_name] = param_value
-                # If argument is not a string, pass as-is (already properly typed)
-                elif not isinstance(param_value, str):
+                ) or not isinstance(param_value, str):
                     converted_kwargs[param_name] = param_value
                 else:
                     # Try to convert string argument using type adapter
@@ -305,7 +308,7 @@ class FunctionPrompt(Prompt):
                         raise PromptError(
                             f"Could not convert argument '{param_name}' with value '{param_value}' "
                             f"to expected type {param.annotation}. Error: {e}"
-                        )
+                        ) from e
             else:
                 # Parameter not in function signature, pass as-is
                 converted_kwargs[param_name] = param_value
@@ -367,10 +370,12 @@ class FunctionPrompt(Prompt):
                                 content=TextContent(type="text", text=content),
                             )
                         )
-                except Exception:
-                    raise PromptError("Could not convert prompt result to message.")
+                except Exception as e:
+                    raise PromptError(
+                        "Could not convert prompt result to message."
+                    ) from e
 
             return messages
-        except Exception:
+        except Exception as e:
             logger.exception(f"Error rendering prompt {self.name}")
-            raise PromptError(f"Error rendering prompt {self.name}.")
+            raise PromptError(f"Error rendering prompt {self.name}.") from e

fastmcp/prompts/prompt_manager.py

@@ -2,7 +2,7 @@ from __future__ import annotations as _annotations
 
 import warnings
 from collections.abc import Awaitable, Callable
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from mcp import GetPromptResult
 
@@ -12,9 +12,6 @@ from fastmcp.prompts.prompt import FunctionPrompt, Prompt, PromptResult
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
 
-if TYPE_CHECKING:
-    from fastmcp.server.server import MountedServer
-
 logger = get_logger(__name__)
 
 
@@ -27,7 +24,6 @@ class PromptManager:
         mask_error_details: bool | None = None,
     ):
         self._prompts: dict[str, Prompt] = {}
-        self._mounted_servers: list[MountedServer] = []
         self.mask_error_details = mask_error_details or settings.mask_error_details
 
         # Default to "warn" if None is provided
@@ -42,52 +38,6 @@ class PromptManager:
 
         self.duplicate_behavior = duplicate_behavior
 
-    def mount(self, server: MountedServer) -> None:
-        """Adds a mounted server as a source for prompts."""
-        self._mounted_servers.append(server)
-
-    async def _load_prompts(self, *, via_server: bool = False) -> dict[str, Prompt]:
-        """
-        The single, consolidated recursive method for fetching prompts. The 'via_server'
-        parameter determines the communication path.
-
-        - via_server=False: Manager-to-manager path for complete, unfiltered inventory
-        - via_server=True: Server-to-server path for filtered MCP requests
-        """
-        all_prompts: dict[str, Prompt] = {}
-
-        for mounted in self._mounted_servers:
-            try:
-                if via_server:
-                    # Use the server-to-server filtered path
-                    child_results = await mounted.server._list_prompts()
-                else:
-                    # Use the manager-to-manager unfiltered path
-                    child_results = await mounted.server._prompt_manager.list_prompts()
-
-                # The combination logic is the same for both paths
-                child_dict = {p.key: p for p in child_results}
-                if mounted.prefix:
-                    for prompt in child_dict.values():
-                        prefixed_prompt = prompt.model_copy(
-                            key=f"{mounted.prefix}_{prompt.key}"
-                        )
-                        all_prompts[prefixed_prompt.key] = prefixed_prompt
-                else:
-                    all_prompts.update(child_dict)
-            except Exception as e:
-                # Skip failed mounts silently, matches existing behavior
-                logger.warning(
-                    f"Failed to get prompts from server: {mounted.server.name!r}, mounted at: {mounted.prefix!r}: {e}"
-                )
-                if settings.mounted_components_raise_on_load_error:
-                    raise
-                continue
-
-        # Finally, add local prompts, which always take precedence
-        all_prompts.update(self._prompts)
-        return all_prompts
-
     async def has_prompt(self, key: str) -> bool:
         """Check if a prompt exists."""
         prompts = await self.get_prompts()
@@ -102,16 +52,9 @@ class PromptManager:
 
     async def get_prompts(self) -> dict[str, Prompt]:
         """
-        Gets the complete, unfiltered inventory of all prompts.
-        """
-        return await self._load_prompts(via_server=False)
-
-    async def list_prompts(self) -> list[Prompt]:
-        """
-        Lists all prompts, applying protocol filtering.
+        Gets the complete, unfiltered inventory of local prompts.
         """
-        prompts_dict = await self._load_prompts(via_server=True)
-        return list(prompts_dict.values())
+        return dict(self._prompts)
 
     def add_prompt_from_fn(
         self,
@@ -160,44 +103,16 @@ class PromptManager:
         Internal API for servers: Finds and renders a prompt, respecting the
         filtered protocol path.
         """
-        # 1. Check local prompts first. The server will have already applied its filter.
-        if name in self._prompts:
-            prompt = await self.get_prompt(name)
-            if not prompt:
-                raise NotFoundError(f"Unknown prompt: {name}")
-
-            try:
-                messages = await prompt.render(arguments)
-                return GetPromptResult(
-                    description=prompt.description, messages=messages
-                )
-
-            # Pass through PromptErrors as-is
-            except PromptError as e:
-                logger.exception(f"Error rendering prompt {name!r}")
-                raise e
-
-            # Handle other exceptions
-            except Exception as e:
-                logger.exception(f"Error rendering prompt {name!r}")
-                if self.mask_error_details:
-                    # Mask internal details
-                    raise PromptError(f"Error rendering prompt {name!r}") from e
-                else:
-                    # Include original error details
-                    raise PromptError(f"Error rendering prompt {name!r}: {e}") from e
-
-        # 2. Check mounted servers using the filtered protocol path.
-        for mounted in reversed(self._mounted_servers):
-            prompt_key = name
-            if mounted.prefix:
-                if name.startswith(f"{mounted.prefix}_"):
-                    prompt_key = name.removeprefix(f"{mounted.prefix}_")
-                else:
-                    continue
-            try:
-                return await mounted.server._get_prompt(prompt_key, arguments)
-            except NotFoundError:
-                continue
-
-        raise NotFoundError(f"Unknown prompt: {name}")
+        prompt = await self.get_prompt(name)
+        try:
+            messages = await prompt.render(arguments)
+            return GetPromptResult(description=prompt.description, messages=messages)
+        except PromptError as e:
+            logger.exception(f"Error rendering prompt {name!r}")
+            raise e
+        except Exception as e:
+            logger.exception(f"Error rendering prompt {name!r}")
+            if self.mask_error_details:
+                raise PromptError(f"Error rendering prompt {name!r}") from e
+            else:
+                raise PromptError(f"Error rendering prompt {name!r}: {e}") from e

fastmcp/resources/__init__.py

@@ -10,13 +10,13 @@ from .types import (
 from .resource_manager import ResourceManager
 
 __all__ = [
-    "Resource",
-    "TextResource",
     "BinaryResource",
-    "FunctionResource",
+    "DirectoryResource",
     "FileResource",
+    "FunctionResource",
     "HttpResource",
-    "DirectoryResource",
-    "ResourceTemplate",
+    "Resource",
     "ResourceManager",
+    "ResourceTemplate",
+    "TextResource",
 ]

fastmcp/resources/resource.py

@@ -2,13 +2,12 @@
 
 from __future__ import annotations
 
-import abc
 import inspect
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Annotated, Any
 
 import pydantic_core
-from mcp.types import Annotations
+from mcp.types import Annotations, Icon
 from mcp.types import Resource as MCPResource
 from pydantic import (
     AnyUrl,
@@ -24,13 +23,14 @@ from fastmcp.server.dependencies import get_context
 from fastmcp.utilities.components import FastMCPComponent
 from fastmcp.utilities.types import (
     find_kwarg_by_type,
+    get_fn_name,
 )
 
 if TYPE_CHECKING:
     pass
 
 
-class Resource(FastMCPComponent, abc.ABC):
+class Resource(FastMCPComponent):
     """Base class for all resources."""
 
     model_config = ConfigDict(validate_default=True)
@@ -72,6 +72,7 @@ class Resource(FastMCPComponent, abc.ABC):
         name: str | None = None,
         title: str | None = None,
         description: str | None = None,
+        icons: list[Icon] | None = None,
         mime_type: str | None = None,
         tags: set[str] | None = None,
         enabled: bool | None = None,
@@ -84,6 +85,7 @@ class Resource(FastMCPComponent, abc.ABC):
             name=name,
             title=title,
             description=description,
+            icons=icons,
             mime_type=mime_type,
             tags=tags,
             enabled=enabled,
@@ -110,10 +112,13 @@ class Resource(FastMCPComponent, abc.ABC):
             raise ValueError("Either name or uri must be provided")
         return self
 
-    @abc.abstractmethod
     async def read(self) -> str | bytes:
-        """Read the resource content."""
-        pass
+        """Read the resource content.
+
+        This method is not implemented in the base Resource class and must be
+        implemented by subclasses.
+        """
+        raise NotImplementedError("Subclasses must implement read()")
 
     def to_mcp_resource(
         self,
@@ -122,16 +127,19 @@ class Resource(FastMCPComponent, abc.ABC):
         **overrides: Any,
     ) -> MCPResource:
         """Convert the resource to an MCPResource."""
-        kwargs = {
-            "uri": self.uri,
-            "name": self.name,
-            "description": self.description,
-            "mimeType": self.mime_type,
-            "title": self.title,
-            "annotations": self.annotations,
-            "_meta": self.get_meta(include_fastmcp_meta=include_fastmcp_meta),
-        }
-        return MCPResource(**kwargs | overrides)
+
+        return MCPResource(
+            name=overrides.get("name", self.name),
+            uri=overrides.get("uri", self.uri),
+            description=overrides.get("description", self.description),
+            mimeType=overrides.get("mimeType", self.mime_type),
+            title=overrides.get("title", self.title),
+            icons=overrides.get("icons", self.icons),
+            annotations=overrides.get("annotations", self.annotations),
+            _meta=overrides.get(
+                "_meta", self.get_meta(include_fastmcp_meta=include_fastmcp_meta)
+            ),
+        )
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(uri={self.uri!r}, name={self.name!r}, description={self.description!r}, tags={self.tags})"
@@ -170,6 +178,7 @@ class FunctionResource(Resource):
         name: str | None = None,
         title: str | None = None,
         description: str | None = None,
+        icons: list[Icon] | None = None,
         mime_type: str | None = None,
         tags: set[str] | None = None,
         enabled: bool | None = None,
@@ -182,9 +191,10 @@ class FunctionResource(Resource):
         return cls(
             fn=fn,
             uri=uri,
-            name=name or fn.__name__,
+            name=name or get_fn_name(fn),
             title=title,
             description=description or inspect.getdoc(fn),
+            icons=icons,
             mime_type=mime_type or "text/plain",
             tags=tags or set(),
             enabled=enabled if enabled is not None else True,
@@ -207,9 +217,7 @@ class FunctionResource(Resource):
 
         if isinstance(result, Resource):
             return await result.read()
-        elif isinstance(result, bytes):
-            return result
-        elif isinstance(result, str):
+        elif isinstance(result, bytes | str):
             return result
         else:
             return pydantic_core.to_json(result, fallback=str).decode()