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

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(
@@ -106,6 +105,7 @@ class Prompt(FastMCPComponent, ABC):
             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)
             ),
@@ -117,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,
@@ -134,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):
@@ -160,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,
@@ -201,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)
 
@@ -253,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,
@@ -283,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
@@ -307,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
@@ -369,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,
@@ -31,7 +30,7 @@ if TYPE_CHECKING:
     pass
 
 
-class Resource(FastMCPComponent, abc.ABC):
+class Resource(FastMCPComponent):
     """Base class for all resources."""
 
     model_config = ConfigDict(validate_default=True)
@@ -73,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,
@@ -85,6 +85,7 @@ class Resource(FastMCPComponent, abc.ABC):
             name=name,
             title=title,
             description=description,
+            icons=icons,
             mime_type=mime_type,
             tags=tags,
             enabled=enabled,
@@ -111,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,
@@ -130,6 +134,7 @@ class Resource(FastMCPComponent, abc.ABC):
             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)
@@ -173,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,
@@ -188,6 +194,7 @@ class FunctionResource(Resource):
             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,
@@ -210,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()

fastmcp/resources/resource_manager.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import inspect
 import warnings
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from pydantic import AnyUrl
 
@@ -19,9 +19,6 @@ from fastmcp.resources.template import (
 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__)
 
 
@@ -43,7 +40,6 @@ class ResourceManager:
         """
         self._resources: dict[str, Resource] = {}
         self._templates: dict[str, ResourceTemplate] = {}
-        self._mounted_servers: list[MountedServer] = []
         self.mask_error_details = mask_error_details or settings.mask_error_details
 
         # Default to "warn" if None is provided
@@ -57,137 +53,13 @@ class ResourceManager:
             )
         self.duplicate_behavior = duplicate_behavior
 
-    def mount(self, server: MountedServer) -> None:
-        """Adds a mounted server as a source for resources and templates."""
-        self._mounted_servers.append(server)
-
     async def get_resources(self) -> dict[str, Resource]:
         """Get all registered resources, keyed by URI."""
-        return await self._load_resources(via_server=False)
+        return dict(self._resources)
 
     async def get_resource_templates(self) -> dict[str, ResourceTemplate]:
         """Get all registered templates, keyed by URI template."""
-        return await self._load_resource_templates(via_server=False)
-
-    async def _load_resources(self, *, via_server: bool = False) -> dict[str, Resource]:
-        """
-        The single, consolidated recursive method for fetching resources. 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_resources: dict[str, Resource] = {}
-
-        for mounted in self._mounted_servers:
-            try:
-                if via_server:
-                    # Use the server-to-server filtered path
-                    child_resources_list = await mounted.server._list_resources()
-                    child_resources = {
-                        resource.key: resource for resource in child_resources_list
-                    }
-                else:
-                    # Use the manager-to-manager unfiltered path
-                    child_resources = (
-                        await mounted.server._resource_manager.get_resources()
-                    )
-
-                # Apply prefix if needed
-                if mounted.prefix:
-                    from fastmcp.server.server import add_resource_prefix
-
-                    for uri, resource in child_resources.items():
-                        prefixed_uri = add_resource_prefix(
-                            uri, mounted.prefix, mounted.resource_prefix_format
-                        )
-                        # Create a copy of the resource with the prefixed key and name
-                        prefixed_resource = resource.model_copy(
-                            update={"name": f"{mounted.prefix}_{resource.name}"},
-                            key=prefixed_uri,
-                        )
-                        all_resources[prefixed_uri] = prefixed_resource
-                else:
-                    all_resources.update(child_resources)
-            except Exception as e:
-                # Skip failed mounts silently, matches existing behavior
-                logger.warning(
-                    f"Failed to get resources 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 resources, which always take precedence
-        all_resources.update(self._resources)
-        return all_resources
-
-    async def _load_resource_templates(
-        self, *, via_server: bool = False
-    ) -> dict[str, ResourceTemplate]:
-        """
-        The single, consolidated recursive method for fetching templates. 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_templates: dict[str, ResourceTemplate] = {}
-
-        for mounted in self._mounted_servers:
-            try:
-                if via_server:
-                    # Use the server-to-server filtered path
-                    child_templates = await mounted.server._list_resource_templates()
-                else:
-                    # Use the manager-to-manager unfiltered path
-                    child_templates = (
-                        await mounted.server._resource_manager.list_resource_templates()
-                    )
-                child_dict = {template.key: template for template in child_templates}
-
-                # Apply prefix if needed
-                if mounted.prefix:
-                    from fastmcp.server.server import add_resource_prefix
-
-                    for uri_template, template in child_dict.items():
-                        prefixed_uri_template = add_resource_prefix(
-                            uri_template, mounted.prefix, mounted.resource_prefix_format
-                        )
-                        # Create a copy of the template with the prefixed key and name
-                        prefixed_template = template.model_copy(
-                            update={"name": f"{mounted.prefix}_{template.name}"},
-                            key=prefixed_uri_template,
-                        )
-                        all_templates[prefixed_uri_template] = prefixed_template
-                else:
-                    all_templates.update(child_dict)
-            except Exception as e:
-                # Skip failed mounts silently, matches existing behavior
-                logger.warning(
-                    f"Failed to get templates 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 templates, which always take precedence
-        all_templates.update(self._templates)
-        return all_templates
-
-    async def list_resources(self) -> list[Resource]:
-        """
-        Lists all resources, applying protocol filtering.
-        """
-        resources_dict = await self._load_resources(via_server=True)
-        return list(resources_dict.values())
-
-    async def list_resource_templates(self) -> list[ResourceTemplate]:
-        """
-        Lists all templates, applying protocol filtering.
-        """
-        templates_dict = await self._load_resource_templates(via_server=True)
-        return list(templates_dict.values())
+        return dict(self._templates)
 
     def add_resource_or_template_from_fn(
         self,
@@ -363,8 +235,8 @@ class ResourceManager:
 
         # Then check templates (local and mounted) only if not found in concrete resources
         templates = await self.get_resource_templates()
-        for template_key in templates.keys():
-            if match_uri_template(uri_str, template_key):
+        for template_key in templates:
+            if match_uri_template(uri_str, template_key) is not None:
                 return True
 
         return False
@@ -381,16 +253,16 @@ class ResourceManager:
         uri_str = str(uri)
         logger.debug("Getting resource", extra={"uri": uri_str})
 
-        # First check concrete resources (local and mounted)
+        # First check concrete resources
         resources = await self.get_resources()
         if resource := resources.get(uri_str):
             return resource
 
-        # Then check templates (local and mounted) - use the utility function to match against storage keys
+        # Then check templates
         templates = await self.get_resource_templates()
         for storage_key, template in templates.items():
             # Try to match against the storage key (which might be a custom key)
-            if params := match_uri_template(uri_str, storage_key):
+            if (params := match_uri_template(uri_str, storage_key)) is not None:
                 try:
                     return await template.create_resource(
                         uri_str,
@@ -424,9 +296,6 @@ class ResourceManager:
         # 1. Check local resources first. The server will have already applied its filter.
         if uri_str in self._resources:
             resource = await self.get_resource(uri_str)
-            if not resource:
-                raise NotFoundError(f"Resource {uri_str!r} not found")
-
             try:
                 return await resource.read()
 
@@ -449,7 +318,7 @@ class ResourceManager:
 
         # 1b. Check local templates if not found in concrete resources
         for key, template in self._templates.items():
-            if params := match_uri_template(uri_str, key):
+            if (params := match_uri_template(uri_str, key)) is not None:
                 try:
                     resource = await template.create_resource(uri_str, params=params)
                     return await resource.read()
@@ -471,32 +340,4 @@ class ResourceManager:
                             f"Error reading resource from template {uri_str!r}: {e}"
                         ) from e
 
-        # 2. Check mounted servers using the filtered protocol path.
-        from fastmcp.server.server import has_resource_prefix, remove_resource_prefix
-
-        for mounted in reversed(self._mounted_servers):
-            key = uri_str
-            try:
-                if mounted.prefix:
-                    if has_resource_prefix(
-                        key,
-                        mounted.prefix,
-                        mounted.resource_prefix_format,
-                    ):
-                        key = remove_resource_prefix(
-                            key,
-                            mounted.prefix,
-                            mounted.resource_prefix_format,
-                        )
-                    else:
-                        continue
-
-                try:
-                    result = await mounted.server._read_resource(key)
-                    return result[0].content
-                except NotFoundError:
-                    continue
-            except NotFoundError:
-                continue
-
         raise NotFoundError(f"Resource {uri_str!r} not found.")