Expand support for various method interactions

src/fastmcp/exceptions.py

@@ -17,5 +17,9 @@ class ToolError(FastMCPError):
     """Error in tool operations."""
 
 
+class PromptError(FastMCPError):
+    """Error in prompt operations."""
+
+
 class InvalidSignature(Exception):
     """Invalid signature for use with FastMCP."""

src/fastmcp/prompts/__init__.py

@@ -1,4 +1,4 @@
-from .prompt import Prompt
+from .prompt import Prompt, Message, UserMessage, AssistantMessage
 from .prompt_manager import PromptManager
 
-__all__ = ["Prompt", "PromptManager"]
+__all__ = ["Prompt", "PromptManager", "Message", "UserMessage", "AssistantMessage"]

src/fastmcp/prompts/prompt.py

@@ -27,27 +27,17 @@ class Message(BaseModel):
         super().__init__(content=content, **kwargs)
 
 
-class UserMessage(Message):
+def UserMessage(content: str | CONTENT_TYPES, **kwargs: Any) -> Message:
     """A message from the user."""
+    return Message(content=content, role="user", **kwargs)
 
-    role: Literal["user", "assistant"] = "user"
 
-    def __init__(self, content: str | CONTENT_TYPES, **kwargs: Any):
-        super().__init__(content=content, **kwargs)
-
-
-class AssistantMessage(Message):
+def AssistantMessage(content: str | CONTENT_TYPES, **kwargs: Any) -> Message:
     """A message from the assistant."""
+    return Message(content=content, role="assistant", **kwargs)
 
-    role: Literal["user", "assistant"] = "assistant"
-
-    def __init__(self, content: str | CONTENT_TYPES, **kwargs: Any):
-        super().__init__(content=content, **kwargs)
 
-
-message_validator = TypeAdapter[UserMessage | AssistantMessage](
-    UserMessage | AssistantMessage
-)
+message_validator = TypeAdapter[Message](Message)
 
 SyncPromptResult = (
     str | Message | dict[str, Any] | Sequence[str | Message | dict[str, Any]]
@@ -160,7 +150,7 @@ class Prompt(BaseModel):
                         messages.append(message_validator.validate_python(msg))
                     elif isinstance(msg, str):
                         content = TextContent(type="text", text=msg)
-                        messages.append(UserMessage(content=content))
+                        messages.append(Message(role="user", content=content))
                     else:
                         content = json.dumps(pydantic_core.to_jsonable_python(msg))
                         messages.append(Message(role="user", content=content))

src/fastmcp/prompts/prompt_manager.py

@@ -3,6 +3,7 @@
 from collections.abc import Awaitable, Callable
 from typing import Any
 
+from fastmcp.exceptions import PromptError
 from fastmcp.prompts.prompt import Message, Prompt, PromptResult
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
@@ -61,7 +62,7 @@ class PromptManager:
         """Render a prompt by name with arguments."""
         prompt = self.get_prompt(name)
         if not prompt:
-            raise ValueError(f"Unknown prompt: {name}")
+            raise PromptError(f"Unknown prompt: {name}")
 
         return await prompt.render(arguments)
 

src/fastmcp/resources/__init__.py

@@ -1,5 +1,4 @@
 from .resource import Resource
-from .resource_manager import ResourceManager
 from .template import ResourceTemplate
 from .types import (
     BinaryResource,
@@ -9,6 +8,7 @@ from .types import (
     HttpResource,
     TextResource,
 )
+from .resource_manager import ResourceManager
 
 __all__ = [
     "Resource",

src/fastmcp/resources/resource_manager.py

@@ -1,11 +1,14 @@
 """Resource manager functionality."""
 
+import inspect
+import re
 from collections.abc import Callable
 from typing import Any
 
 from pydantic import AnyUrl
 
-from fastmcp.resources.resource import Resource
+from fastmcp.exceptions import ResourceError
+from fastmcp.resources import FunctionResource, Resource
 from fastmcp.resources.template import ResourceTemplate
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
@@ -21,16 +24,86 @@ class ResourceManager:
         self._templates: dict[str, ResourceTemplate] = {}
         self.duplicate_behavior = duplicate_behavior
 
-    def add_resource(self, resource: Resource) -> Resource:
-        """Add a resource to the manager.
+    def add_resource_or_template_from_fn(
+        self,
+        fn: Callable[..., Any],
+        uri: str,
+        name: str | None = None,
+        description: str | None = None,
+        mime_type: str | None = None,
+        tags: set[str] | None = None,
+    ) -> Resource | ResourceTemplate:
+        """Add a resource or template to the manager from a function.
 
         Args:
-            resource: A Resource instance to add
+            fn: The function to register as a resource or template
+            uri: The URI for the resource or template
+            name: Optional name for the resource or template
+            description: Optional description of the resource or template
+            mime_type: Optional MIME type for the resource or template
+            tags: Optional set of tags for categorizing the resource or template
+
+        Returns:
+            The added resource or template. If a resource or template with the same URI already exists,
+            returns the existing resource or template.
+        """
+        # Check if this should be a template
+        has_uri_params = "{" in uri and "}" in uri
+        has_func_params = bool(inspect.signature(fn).parameters)
+
+        if has_uri_params and has_func_params:
+            return self.add_template_from_fn(
+                fn, uri, name, description, mime_type, tags
+            )
+        elif not has_uri_params and not has_func_params:
+            return self.add_resource_from_fn(
+                fn, uri, name, description, mime_type, tags
+            )
+        else:
+            raise ValueError(
+                "Invalid resource or template definition due to a "
+                "mismatch between URI parameters and function parameters."
+            )
+
+    def add_resource_from_fn(
+        self,
+        fn: Callable[..., Any],
+        uri: str,
+        name: str | None = None,
+        description: str | None = None,
+        mime_type: str | None = None,
+        tags: set[str] | None = None,
+    ) -> Resource:
+        """Add a resource to the manager from a function.
+
+        Args:
+            fn: The function to register as a resource
+            uri: The URI for the resource
+            name: Optional name for the resource
+            description: Optional description of the resource
+            mime_type: Optional MIME type for the resource
+            tags: Optional set of tags for categorizing the resource
 
         Returns:
             The added resource. If a resource with the same URI already exists,
             returns the existing resource.
         """
+        resource = FunctionResource(
+            uri=AnyUrl(uri),
+            name=name,
+            description=description,
+            mime_type=mime_type or "text/plain",
+            fn=fn,
+            tags=tags or set(),
+        )
+        return self.add_resource(resource)
+
+    def add_resource(self, resource: Resource) -> Resource:
+        """Add a resource to the manager.
+
+        Args:
+            resource: A Resource instance to add
+        """
         logger.debug(
             "Adding resource",
             extra={
@@ -63,6 +136,17 @@ class ResourceManager:
         tags: set[str] | None = None,
     ) -> ResourceTemplate:
         """Create a template from a function."""
+
+        # Validate that URI params match function params
+        uri_params = set(re.findall(r"{(\w+)}", uri_template))
+        func_params = set(inspect.signature(fn).parameters.keys())
+
+        if uri_params != func_params:
+            raise ValueError(
+                f"Mismatch between URI parameters {uri_params} "
+                f"and function parameters {func_params}"
+            )
+
         template = ResourceTemplate.from_function(
             fn,
             uri_template=uri_template,
@@ -122,7 +206,7 @@ class ResourceManager:
                 except Exception as e:
                     raise ValueError(f"Error creating resource from template: {e}")
 
-        raise ValueError(f"Unknown resource: {uri}")
+        raise ResourceError(f"Unknown resource: {uri}")
 
     def list_resources(self) -> list[Resource]:
         """List all registered resources."""

src/fastmcp/server/context.py

@@ -118,7 +118,7 @@ class Context(BaseModel, Generic[ServerSessionT, LifespanContextT]):
         assert self._fastmcp is not None, (
             "Context is not available outside of a request"
         )
-        return await self._fastmcp.read_resource(uri)
+        return await self._fastmcp._mcp_read_resource(uri)
 
     async def log(
         self,

src/fastmcp/server/proxy.py

@@ -1,11 +1,11 @@
 from typing import Any, cast
 
 import mcp.types
-from mcp.types import BlobResourceContents, PromptMessage, TextResourceContents
+from mcp.types import BlobResourceContents, TextResourceContents
 
 import fastmcp
 from fastmcp.client import Client
-from fastmcp.prompts import Prompt
+from fastmcp.prompts import Message, Prompt
 from fastmcp.resources import Resource, ResourceTemplate
 from fastmcp.server.context import Context
 from fastmcp.server.server import FastMCP
@@ -142,10 +142,10 @@ class ProxyPrompt(Prompt):
             fn=_proxy_passthrough,
         )
 
-    async def render(self, arguments: dict[str, Any]) -> list[PromptMessage]:
+    async def render(self, arguments: dict[str, Any]) -> list[Message]:
         async with self._client:
             result = await self._client.get_prompt(self.name, arguments)
-        return result.messages
+        return [Message(role=m.role, content=m.content) for m in result.messages]
 
 
 class FastMCPProxy(FastMCP):

src/fastmcp/server/server.py

@@ -1,9 +1,7 @@
 """FastMCP - A more ergonomic interface for MCP servers."""
 
-import inspect
 import json
-import re
-from collections.abc import AsyncIterator, Callable
+from collections.abc import AsyncIterator, Awaitable, Callable
 from contextlib import (
     AbstractAsyncContextManager,
     AsyncExitStack,
@@ -43,8 +41,12 @@ import fastmcp
 import fastmcp.settings
 from fastmcp.exceptions import ResourceError
 from fastmcp.prompts import Prompt, PromptManager
-from fastmcp.resources import FunctionResource, Resource, ResourceManager
+from fastmcp.prompts.prompt import Message, PromptResult
+from fastmcp.resources import Resource, ResourceManager
+from fastmcp.resources.template import ResourceTemplate
 from fastmcp.tools import ToolManager
+from fastmcp.tools.tool import Tool
+from fastmcp.utilities.decorators import DecoratedFunction
 from fastmcp.utilities.logging import configure_logging, get_logger
 from fastmcp.utilities.types import Image
 
@@ -171,18 +173,27 @@ class FastMCP(Generic[LifespanResultT]):
 
     def _setup_handlers(self) -> None:
         """Set up core MCP protocol handlers."""
-        self._mcp_server.list_tools()(self.list_tools)
+        self._mcp_server.list_tools()(self._mcp_list_tools)
         self._mcp_server.call_tool()(self.call_tool)
-        self._mcp_server.list_resources()(self.list_resources)
-        self._mcp_server.read_resource()(self.read_resource)
-        self._mcp_server.list_prompts()(self.list_prompts)
-        self._mcp_server.get_prompt()(self.get_prompt)
-        self._mcp_server.list_resource_templates()(self.list_resource_templates)
+        self._mcp_server.list_resources()(self._mcp_list_resources)
+        self._mcp_server.read_resource()(self._mcp_read_resource)
+        self._mcp_server.list_prompts()(self._mcp_list_prompts)
+        self._mcp_server.get_prompt()(self._mcp_get_prompt)
+        self._mcp_server.list_resource_templates()(self._mcp_list_resource_templates)
 
-    async def list_tools(self) -> list[MCPTool]:
-        """List all available tools."""
+    def list_tools(self) -> list[Tool]:
+        return self._tool_manager.list_tools()
+
+    async def _mcp_list_tools(self) -> list[MCPTool]:
+        """
+        List all available tools, in the format expected by the low-level MCP
+        server.
+
+        See `list_tools` for a more ergonomic way to list tools.
+        """
+
+        tools = self.list_tools()
 
-        tools = self._tool_manager.list_tools()
         return [
             MCPTool(
                 name=info.name,
@@ -215,10 +226,18 @@ class FastMCP(Generic[LifespanResultT]):
         converted_result = _convert_to_content(result)
         return converted_result
 
-    async def list_resources(self) -> list[MCPResource]:
-        """List all available resources."""
+    def list_resources(self) -> list[Resource]:
+        return self._resource_manager.list_resources()
+
+    async def _mcp_list_resources(self) -> list[MCPResource]:
+        """
+        List all available resources, in the format expected by the low-level MCP
+        server.
+
+        See `list_resources` for a more ergonomic way to list resources.
+        """
 
-        resources = self._resource_manager.list_resources()
+        resources = self.list_resources()
         return [
             MCPResource(
                 uri=resource.uri,
@@ -229,8 +248,18 @@ class FastMCP(Generic[LifespanResultT]):
             for resource in resources
         ]
 
-    async def list_resource_templates(self) -> list[MCPResourceTemplate]:
-        templates = self._resource_manager.list_templates()
+    def list_resource_templates(self) -> list[ResourceTemplate]:
+        return self._resource_manager.list_templates()
+
+    async def _mcp_list_resource_templates(self) -> list[MCPResourceTemplate]:
+        """
+        List all available resource templates, in the format expected by the low-level
+        MCP server.
+
+        See `list_resource_templates` for a more ergonomic way to list resource
+        templates.
+        """
+        templates = self.list_resource_templates()
         return [
             MCPResourceTemplate(
                 uriTemplate=template.uri_template,
@@ -240,15 +269,27 @@ class FastMCP(Generic[LifespanResultT]):
             for template in templates
         ]
 
-    async def read_resource(self, uri: AnyUrl | str) -> list[ReadResourceContents]:
+    async def read_resource(self, uri: AnyUrl | str) -> str | bytes:
         """Read a resource by URI."""
+        resource = await self._resource_manager.get_resource(uri)
+        if not resource:
+            raise ResourceError(f"Unknown resource: {uri}")
+        return await resource.read()
+
+    async def _mcp_read_resource(self, uri: AnyUrl | str) -> list[ReadResourceContents]:
+        """
+        Read a resource by URI, in the format expected by the low-level MCP
+        server.
+
+        See `read_resource` for a more ergonomic way to read resources.
+        """
 
         resource = await self._resource_manager.get_resource(uri)
         if not resource:
             raise ResourceError(f"Unknown resource: {uri}")
 
         try:
-            content = await resource.read()
+            content = await self.read_resource(uri)
             return [ReadResourceContents(content=content, mime_type=resource.mime_type)]
         except Exception as e:
             logger.error(f"Error reading resource {uri}: {e}")
@@ -308,6 +349,7 @@ class FastMCP(Generic[LifespanResultT]):
                 await context.report_progress(50, 100)
                 return str(x)
         """
+
         # Check if user passed function directly instead of calling decorator
         if callable(name):
             raise TypeError(
@@ -317,7 +359,7 @@ class FastMCP(Generic[LifespanResultT]):
 
         def decorator(fn: AnyFunction) -> AnyFunction:
             self.add_tool(fn, name=name, description=description, tags=tags)
-            return fn
+            return DecoratedFunction(fn)
 
         return decorator
 
@@ -327,8 +369,40 @@ class FastMCP(Generic[LifespanResultT]):
         Args:
             resource: A Resource instance to add
         """
+
         self._resource_manager.add_resource(resource)
 
+    def add_resource_from_fn(
+        self,
+        fn: AnyFunction,
+        uri: str,
+        name: str | None = None,
+        description: str | None = None,
+        mime_type: str | None = None,
+        tags: set[str] | None = None,
+    ) -> None:
+        """Add a resource or template to the server from a function.
+
+        If the URI contains parameters (e.g. "resource://{param}") or the function
+        has parameters, it will be registered as a template resource.
+
+        Args:
+            fn: The function to register as a resource
+            uri: The URI for the resource
+            name: Optional name for the resource
+            description: Optional description of the resource
+            mime_type: Optional MIME type for the resource
+            tags: Optional set of tags for categorizing the resource
+        """
+        self._resource_manager.add_resource_or_template_from_fn(
+            fn=fn,
+            uri=uri,
+            name=name,
+            description=description,
+            mime_type=mime_type,
+            tags=tags,
+        )
+
     def resource(
         self,
         uri: str,
@@ -383,52 +457,36 @@ class FastMCP(Generic[LifespanResultT]):
             )
 
         def decorator(fn: AnyFunction) -> AnyFunction:
-            # Check if this should be a template
-            has_uri_params = "{" in uri and "}" in uri
-            has_func_params = bool(inspect.signature(fn).parameters)
-
-            if has_uri_params or has_func_params:
-                # Validate that URI params match function params
-                uri_params = set(re.findall(r"{(\w+)}", uri))
-                func_params = set(inspect.signature(fn).parameters.keys())
-
-                if uri_params != func_params:
-                    raise ValueError(
-                        f"Mismatch between URI parameters {uri_params} "
-                        f"and function parameters {func_params}"
-                    )
-
-                # Register as template
-                self._resource_manager.add_template_from_fn(
-                    fn=fn,
-                    uri_template=uri,
-                    name=name,
-                    description=description,
-                    mime_type=mime_type or "text/plain",
-                    tags=tags,
-                )
-            else:
-                # Register as regular resource
-                resource = FunctionResource(
-                    uri=AnyUrl(uri),
-                    name=name,
-                    description=description,
-                    mime_type=mime_type or "text/plain",
-                    fn=fn,
-                    tags=tags or set(),  # Default to empty set if None
-                )
-                self.add_resource(resource)
-            return fn
+            self._resource_manager.add_resource_or_template_from_fn(
+                fn=fn,
+                uri=uri,
+                name=name,
+                description=description,
+                mime_type=mime_type,
+                tags=tags,
+            )
+            return DecoratedFunction(fn)
 
         return decorator
 
-    def add_prompt(self, prompt: Prompt) -> None:
+    def add_prompt(
+        self,
+        fn: Callable[..., PromptResult | Awaitable[PromptResult]],
+        name: str | None = None,
+        description: str | None = None,
+        tags: set[str] | None = None,
+    ) -> None:
         """Add a prompt to the server.
 
         Args:
             prompt: A Prompt instance to add
         """
-        self._prompt_manager.add_prompt(prompt)
+        self._prompt_manager.add_prompt_from_fn(
+            fn=fn,
+            name=name,
+            description=description,
+            tags=tags,
+        )
 
     def prompt(
         self,
@@ -478,11 +536,8 @@ class FastMCP(Generic[LifespanResultT]):
             )
 
         def decorator(func: AnyFunction) -> AnyFunction:
-            prompt = Prompt.from_function(
-                func, name=name, description=description, tags=tags
-            )
-            self.add_prompt(prompt)
-            return func
+            self.add_prompt(func, name=name, description=description, tags=tags)
+            return DecoratedFunction(func)
 
         return decorator
 
@@ -537,9 +592,20 @@ class FastMCP(Generic[LifespanResultT]):
             ],
         )
 
-    async def list_prompts(self) -> list[MCPPrompt]:
-        """List all available prompts."""
-        prompts = self._prompt_manager.list_prompts()
+    def list_prompts(self) -> list[Prompt]:
+        """
+        List all available prompts.
+        """
+        return self._prompt_manager.list_prompts()
+
+    async def _mcp_list_prompts(self) -> list[MCPPrompt]:
+        """
+        List all available prompts, in the format expected by the low-level MCP
+        server.
+
+        See `list_prompts` for a more ergonomic way to list prompts.
+        """
+        prompts = self.list_prompts()
         return [
             MCPPrompt(
                 name=prompt.name,
@@ -558,10 +624,21 @@ class FastMCP(Generic[LifespanResultT]):
 
     async def get_prompt(
         self, name: str, arguments: dict[str, Any] | None = None
-    ) -> GetPromptResult:
+    ) -> list[Message]:
         """Get a prompt by name with arguments."""
+        return await self._prompt_manager.render_prompt(name, arguments)
+
+    async def _mcp_get_prompt(
+        self, name: str, arguments: dict[str, Any] | None = None
+    ) -> GetPromptResult:
+        """
+        Get a prompt by name with arguments, in the format expected by the low-level
+        MCP server.
+
+        See `get_prompt` for a more ergonomic way to get prompts.
+        """
         try:
-            messages = await self._prompt_manager.render_prompt(name, arguments)
+            messages = await self.get_prompt(name, arguments)
 
             return GetPromptResult(messages=pydantic_core.to_jsonable_python(messages))
         except Exception as e:

src/fastmcp/tools/tool.py

@@ -58,7 +58,10 @@ class Tool(BaseModel):
         is_async = inspect.iscoroutinefunction(fn)
 
         if context_kwarg is None:
-            sig = inspect.signature(fn)
+            if isinstance(fn, classmethod):
+                sig = inspect.signature(fn.__func__)
+            else:
+                sig = inspect.signature(fn)
             for param_name, param in sig.parameters.items():
                 if param.annotation is Context:
                     context_kwarg = param_name

src/fastmcp/utilities/decorators.py

@@ -0,0 +1,101 @@
+import inspect
+from collections.abc import Callable
+from typing import Generic, ParamSpec, TypeVar, cast, overload
+
+from typing_extensions import Self
+
+R = TypeVar("R")
+P = ParamSpec("P")
+
+
+class DecoratedFunction(Generic[P, R]):
+    """Descriptor for decorated functions.
+
+    You can return this object from a decorator to ensure that it works across
+    all types of functions: vanilla, instance methods, class methods, and static
+    methods; both synchronous and asynchronous.
+
+    This class is used to store the original function and metadata about how to
+    register it as a tool.
+
+    Example usage:
+
+    ```python
+    def my_decorator(fn: Callable[P, R]) -> DecoratedFunction[P, R]:
+        return DecoratedFunction(fn)
+    ```
+
+    On a function:
+    ```python
+    @my_decorator
+    def my_function(a: int, b: int) -> int:
+        return a + b
+    ```
+
+    On an instance method:
+    ```python
+    class Test:
+        @my_decorator
+        def my_function(self, a: int, b: int) -> int:
+            return a + b
+    ```
+
+    On a class method:
+    ```python
+    class Test:
+        @classmethod
+        @my_decorator
+        def my_function(cls, a: int, b: int) -> int:
+            return a + b
+    ```
+
+    Note that for classmethods, the decorator must be applied first, then
+    `@classmethod` on top.
+
+    On a static method:
+    ```python
+    class Test:
+        @staticmethod
+        @my_decorator
+        def my_function(a: int, b: int) -> int:
+            return a + b
+    ```
+    """
+
+    def __init__(self, fn: Callable[P, R]):
+        self.fn = fn
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+        """Call the original function."""
+        try:
+            return self.fn(*args, **kwargs)
+        except TypeError as e:
+            if "'classmethod' object is not callable" in str(e):
+                raise TypeError(
+                    "To apply this decorator to a classmethod, apply the decorator first, then @classmethod on top."
+                )
+            raise
+
+    @overload
+    def __get__(self, instance: None, owner: type | None = None) -> Self: ...
+
+    @overload
+    def __get__(
+        self, instance: object, owner: type | None = None
+    ) -> Callable[P, R]: ...
+
+    def __get__(
+        self, instance: object | None, owner: type | None = None
+    ) -> Self | Callable[P, R]:
+        """Return the original function when accessed from an instance, or self when accessed from the class."""
+        if instance is None:
+            return self
+        # Return the original function bound to the instance
+        return cast(Callable[P, R], self.fn.__get__(instance, owner))
+
+    def __repr__(self) -> str:
+        """Return a representation that matches Python's function representation."""
+        module = getattr(self.fn, "__module__", "unknown")
+        qualname = getattr(self.fn, "__qualname__", str(self.fn))
+        sig_str = str(inspect.signature(self.fn))
+        return f"<function {module}.{qualname}{sig_str}>"

src/fastmcp/utilities/func_metadata.py

@@ -125,7 +125,10 @@ def func_metadata(
     Returns:
         A pydantic model representing the function's signature.
     """
-    sig = _get_typed_signature(func)
+    if isinstance(func, classmethod):
+        sig = _get_typed_signature(func.__func__)
+    else:
+        sig = _get_typed_signature(func)
     params = sig.parameters
     dynamic_pydantic_model_params: dict[str, Any] = {}
     globalns = getattr(func, "__globals__", {})

tests/prompts/test_prompt_manager.py

@@ -1,5 +1,6 @@
 import pytest
 
+from fastmcp.exceptions import PromptError
 from fastmcp.prompts import Prompt
 from fastmcp.prompts.prompt import PromptArgument, TextContent, UserMessage
 from fastmcp.prompts.prompt_manager import PromptManager
@@ -97,7 +98,7 @@ class TestPromptManager:
     async def test_render_unknown_prompt(self):
         """Test rendering a non-existent prompt."""
         manager = PromptManager()
-        with pytest.raises(ValueError, match="Unknown prompt: unknown"):
+        with pytest.raises(PromptError, match="Unknown prompt: unknown"):
             await manager.render_prompt("unknown")
 
     @pytest.mark.anyio

tests/resources/test_resource_manager.py

@@ -4,6 +4,7 @@ from tempfile import NamedTemporaryFile
 import pytest
 from pydantic import AnyUrl, FileUrl
 
+from fastmcp.exceptions import ResourceError
 from fastmcp.resources import (
     FileResource,
     FunctionResource,
@@ -156,7 +157,7 @@ class TestResourceManager:
     async def test_get_unknown_resource(self):
         """Test getting a non-existent resource."""
         manager = ResourceManager()
-        with pytest.raises(ValueError, match="Unknown resource"):
+        with pytest.raises(ResourceError, match="Unknown resource"):
             await manager.get_resource(AnyUrl("unknown://test"))
 
     def test_list_resources(self, temp_file: Path):

tests/server/test_file_server.py

@@ -75,7 +75,7 @@ def tools(mcp: FastMCP, test_dir: Path) -> FastMCP:
 
 @pytest.mark.anyio
 async def test_list_resources(mcp: FastMCP):
-    resources = await mcp.list_resources()
+    resources = await mcp._mcp_list_resources()
     assert len(resources) == 4
 
     assert [str(r.uri) for r in resources] == [
@@ -88,7 +88,7 @@ async def test_list_resources(mcp: FastMCP):
 
 @pytest.mark.anyio
 async def test_read_resource_dir(mcp: FastMCP):
-    res_iter = await mcp.read_resource("dir://test_dir")
+    res_iter = await mcp._mcp_read_resource("dir://test_dir")
     res_list = list(res_iter)
     assert len(res_list) == 1
     res = res_list[0]
@@ -105,7 +105,7 @@ async def test_read_resource_dir(mcp: FastMCP):
 
 @pytest.mark.anyio
 async def test_read_resource_file(mcp: FastMCP):
-    res_iter = await mcp.read_resource("file://test_dir/example.py")
+    res_iter = await mcp._mcp_read_resource("file://test_dir/example.py")
     res_list = list(res_iter)
     assert len(res_list) == 1
     res = res_list[0]
@@ -125,7 +125,7 @@ async def test_delete_file_and_check_resources(mcp: FastMCP, test_dir: Path):
     await mcp.call_tool(
         "delete_file", arguments=dict(path=str(test_dir / "example.py"))
     )
-    res_iter = await mcp.read_resource("file://test_dir/example.py")
+    res_iter = await mcp._mcp_read_resource("file://test_dir/example.py")
     res_list = list(res_iter)
     assert len(res_list) == 1
     res = res_list[0]

tests/server/test_openapi.py

@@ -117,7 +117,7 @@ class TestTools:
         """
         By default, tools exclude GET methods
         """
-        tools = await fastmcp_server.list_tools()
+        tools = await fastmcp_server._mcp_list_tools()
         assert len(tools) == 2
 
         assert tools[0].model_dump() == dict(
@@ -164,7 +164,7 @@ class TestTools:
         assert len(response.json()) == 4
 
         # Check that the user was created via MCP
-        user_response = await fastmcp_server.read_resource(
+        user_response = await fastmcp_server._mcp_read_resource(
             "resource://openapi/get_user_users__user_id__get/4"
         )
         user = user_response[0].content
@@ -186,7 +186,7 @@ class TestTools:
         assert dict(id=1, name="XYZ", active=True) in response.json()
 
         # Check that the user was updated via MCP
-        user_response = await fastmcp_server.read_resource(
+        user_response = await fastmcp_server._mcp_read_resource(
             "resource://openapi/get_user_users__user_id__get/1"
         )
         user = user_response[0].content
@@ -198,7 +198,7 @@ class TestResources:
         """
         By default, resources exclude GET methods without parameters
         """
-        resources = await fastmcp_server.list_resources()
+        resources = await fastmcp_server._mcp_list_resources()
         assert len(resources) == 1
         assert resources[0].uri == AnyUrl("resource://openapi/get_users_users_get")
         assert resources[0].name == "get_users_users_get"
@@ -212,7 +212,7 @@ class TestResources:
         json_users = TypeAdapter(list[User]).dump_python(
             sorted(users_db.values(), key=lambda x: x.id)
         )
-        resource_response = await fastmcp_server.read_resource(
+        resource_response = await fastmcp_server._mcp_read_resource(
             "resource://openapi/get_users_users_get"
         )
         resource = resource_response[0].content
@@ -226,7 +226,7 @@ class TestResourceTemplates:
         """
         By default, resource templates exclude GET methods without parameters
         """
-        resource_templates = await fastmcp_server.list_resource_templates()
+        resource_templates = await fastmcp_server._mcp_list_resource_templates()
         assert len(resource_templates) == 1
         assert resource_templates[0].name == "get_user_users__user_id__get"
         assert (
@@ -241,7 +241,7 @@ class TestResourceTemplates:
         The resource template created by the OpenAPI server should be the same as the original
         """
         user_id = 2
-        resource_response = await fastmcp_server.read_resource(
+        resource_response = await fastmcp_server._mcp_read_resource(
             f"resource://openapi/get_user_users__user_id__get/{user_id}"
         )
 
@@ -256,7 +256,7 @@ class TestPrompts:
         """
         By default, there are no prompts.
         """
-        prompts = await fastmcp_server.list_prompts()
+        prompts = await fastmcp_server._mcp_list_prompts()
         assert len(prompts) == 0
 
 

tests/server/test_proxy.py

@@ -7,6 +7,7 @@ from dirty_equals import Contains
 from fastmcp import FastMCP
 from fastmcp.client import Client
 from fastmcp.client.transports import FastMCPTransport
+from fastmcp.exceptions import ResourceError
 from fastmcp.server.proxy import FastMCPProxy
 
 USERS = [
@@ -80,11 +81,14 @@ async def test_create_proxy(fastmcp_server):
 
 class TestTools:
     async def test_list_tools(self, proxy_server):
-        tools = await proxy_server.list_tools()
+        tools = proxy_server.list_tools()
         assert [t.name for t in tools] == Contains("greet", "add", "error_tool")
 
     async def test_list_tools_same_as_original(self, fastmcp_server, proxy_server):
-        assert await proxy_server.list_tools() == await fastmcp_server.list_tools()
+        assert (
+            await proxy_server._mcp_list_tools()
+            == await fastmcp_server._mcp_list_tools()
+        )
 
     async def test_call_tool_result_same_as_original(
         self, fastmcp_server: FastMCP, proxy_server: FastMCPProxy
@@ -106,19 +110,20 @@ class TestTools:
 
 class TestResources:
     async def test_list_resources(self, proxy_server):
-        resources = await proxy_server.list_resources()
+        resources = proxy_server.list_resources()
         assert [r.name for r in resources] == Contains(
             "data://users", "resource://wave"
         )
 
     async def test_list_resources_same_as_original(self, fastmcp_server, proxy_server):
         assert (
-            await proxy_server.list_resources() == await fastmcp_server.list_resources()
+            await proxy_server._mcp_list_resources()
+            == await fastmcp_server._mcp_list_resources()
         )
 
     async def test_read_resource(self, proxy_server: FastMCPProxy):
         result = await proxy_server.read_resource("resource://wave")
-        assert result[0].content == "👋"  # type: ignore
+        assert result == "👋"
 
     async def test_read_resource_same_as_original(self, fastmcp_server, proxy_server):
         result = await fastmcp_server.read_resource("resource://wave")
@@ -127,31 +132,31 @@ class TestResources:
 
     async def test_read_json_resource(self, proxy_server: FastMCPProxy):
         result = await proxy_server.read_resource("data://users")
-        assert json.loads(result[0].content) == USERS  # type: ignore
+        assert json.loads(result) == USERS
 
     async def test_read_resource_returns_none_if_not_found(self, proxy_server):
         with pytest.raises(
-            ValueError, match="Unknown resource: resource://nonexistent"
+            ResourceError, match="Unknown resource: resource://nonexistent"
         ):
             await proxy_server.read_resource("resource://nonexistent")
 
 
 class TestResourceTemplates:
     async def test_list_resource_templates(self, proxy_server):
-        templates = await proxy_server.list_resource_templates()
+        templates = proxy_server.list_resource_templates()
         assert [t.name for t in templates] == Contains("get_user")
 
     async def test_list_resource_templates_same_as_original(
         self, fastmcp_server, proxy_server
     ):
-        result = await fastmcp_server.list_resource_templates()
-        proxy_result = await proxy_server.list_resource_templates()
+        result = await fastmcp_server._mcp_list_resource_templates()
+        proxy_result = await proxy_server._mcp_list_resource_templates()
         assert proxy_result == result
 
     @pytest.mark.parametrize("id", [1, 2, 3])
     async def test_read_resource_template(self, proxy_server: FastMCPProxy, id: int):
         result = await proxy_server.read_resource(f"data://user/{id}")
-        assert json.loads(result[0].content) == USERS[id - 1]  # type: ignore
+        assert json.loads(result) == USERS[id - 1]
 
     async def test_read_resource_template_same_as_original(
         self, fastmcp_server, proxy_server
@@ -163,11 +168,14 @@ class TestResourceTemplates:
 
 class TestPrompts:
     async def test_list_prompts(self, proxy_server):
-        prompts = await proxy_server.list_prompts()
+        prompts = proxy_server.list_prompts()
         assert [p.name for p in prompts] == Contains("welcome")
 
     async def test_list_prompts_same_as_original(self, fastmcp_server, proxy_server):
-        assert await proxy_server.list_prompts() == await fastmcp_server.list_prompts()
+        assert (
+            await proxy_server._mcp_list_prompts()
+            == await fastmcp_server._mcp_list_prompts()
+        )
 
     async def test_render_prompt_same_as_original(
         self, fastmcp_server: FastMCP, proxy_server
@@ -178,4 +186,4 @@ class TestPrompts:
 
     async def test_render_prompt_calls_prompt(self, proxy_server):
         result = await proxy_server.get_prompt("welcome", {"name": "Alice"})
-        assert result.messages[0].content.text == "Welcome to FastMCP, Alice!"
+        assert result[0].content.text == "Welcome to FastMCP, Alice!"

tests/server/test_server.py

@@ -14,7 +14,7 @@ from mcp.types import (
 from pydantic import AnyUrl, Field
 
 from fastmcp import Client, Context, FastMCP
-from fastmcp.exceptions import ToolError
+from fastmcp.exceptions import ResourceError, ToolError
 from fastmcp.prompts.prompt import EmbeddedResource, Message, UserMessage
 from fastmcp.resources import FileResource, FunctionResource
 from fastmcp.utilities.types import Image
@@ -56,16 +56,26 @@ class TestCreateServer:
             assert isinstance(content, TextContent)
             assert "¡Hola, 世界! 👋" == content.text
 
-    async def test_add_tool_decorator(self):
+
+class TestToolDecorator:
+    async def test_no_tools_before_decorator(self):
+        mcp = FastMCP()
+
+        with pytest.raises(ToolError, match="Unknown tool: add"):
+            await mcp.call_tool("add", {"x": 1, "y": 2})
+
+    async def test_tool_decorator(self):
         mcp = FastMCP()
 
         @mcp.tool()
         def add(x: int, y: int) -> int:
             return x + y
 
-        assert len(mcp._tool_manager.list_tools()) == 1
+        result = await mcp.call_tool("add", {"x": 1, "y": 2})
+        assert isinstance(result[0], TextContent)
+        assert result[0].text == "3"
 
-    async def test_add_tool_decorator_incorrect_usage(self):
+    async def test_tool_decorator_incorrect_usage(self):
         mcp = FastMCP()
 
         with pytest.raises(TypeError, match="The @tool decorator was used incorrectly"):
@@ -74,16 +84,145 @@ class TestCreateServer:
             def add(x: int, y: int) -> int:
                 return x + y
 
-    async def test_add_resource_decorator(self):
+    async def test_tool_decorator_with_name(self):
         mcp = FastMCP()
 
-        @mcp.resource("r://{x}")
-        def get_data(x: str) -> str:
-            return f"Data: {x}"
+        @mcp.tool(name="custom-add")
+        def add(x: int, y: int) -> int:
+            return x + y
 
-        assert len(mcp._resource_manager._templates) == 1
+        result = await mcp.call_tool("custom-add", {"x": 1, "y": 2})
+        assert isinstance(result[0], TextContent)
+        assert result[0].text == "3"
+
+    async def test_tool_decorator_with_description(self):
+        mcp = FastMCP()
+
+        @mcp.tool(description="Add two numbers")
+        def add(x: int, y: int) -> int:
+            return x + y
+
+        tools = await mcp._mcp_list_tools()
+        assert len(tools) == 1
+        tool = tools[0]
+        assert tool.description == "Add two numbers"
+
+    async def test_tool_decorator_instance_method(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            def __init__(self, x: int):
+                self.x = x
+
+            @mcp.tool()
+            def add(self, y: int) -> int:
+                return self.x + y
+
+        obj = MyClass(10)
+        mcp.add_tool(obj.add)
+        result = await mcp.call_tool("add", {"y": 2})
+        assert isinstance(result[0], TextContent)
+        assert result[0].text == "12"
+
+    async def test_tool_decorator_classmethod(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            x: int = 10
+
+            @classmethod
+            def add(cls, y: int) -> int:
+                return cls.x + y
+
+        mcp.add_tool(MyClass.add)
+        result = await mcp.call_tool("add", {"y": 2})
+        assert isinstance(result[0], TextContent)
+        assert result[0].text == "12"
+
+    async def test_tool_decorator_staticmethod(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            @staticmethod
+            @mcp.tool()
+            def add(x: int, y: int) -> int:
+                return x + y
+
+        result = await mcp.call_tool("add", {"x": 1, "y": 2})
+        assert isinstance(result[0], TextContent)
+        assert result[0].text == "3"
+
+    async def test_tool_decorator_async_function(self):
+        mcp = FastMCP()
+
+        @mcp.tool()
+        async def add(x: int, y: int) -> int:
+            return x + y
+
+        result = await mcp.call_tool("add", {"x": 1, "y": 2})
+        assert isinstance(result[0], TextContent)
+        assert result[0].text == "3"
+
+    async def test_tool_decorator_classmethod_async_function(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            x = 10
+
+            @classmethod
+            async def add(cls, y: int) -> int:
+                return cls.x + y
 
-    async def test_add_resource_decorator_incorrect_usage(self):
+        mcp.add_tool(MyClass.add)
+        result = await mcp.call_tool("add", {"y": 2})
+        assert isinstance(result[0], TextContent)
+        assert result[0].text == "12"
+
+    async def test_tool_decorator_staticmethod_async_function(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            @staticmethod
+            async def add(x: int, y: int) -> int:
+                return x + y
+
+        mcp.add_tool(MyClass.add)
+        result = await mcp.call_tool("add", {"x": 1, "y": 2})
+        assert isinstance(result[0], TextContent)
+        assert result[0].text == "3"
+
+    async def test_tool_decorator_with_tags(self):
+        """Test that the tool decorator properly sets tags."""
+        mcp = FastMCP()
+
+        @mcp.tool(tags={"example", "test-tag"})
+        def sample_tool(x: int) -> int:
+            return x * 2
+
+        # Verify the tags were set correctly
+        tools = mcp._tool_manager.list_tools()
+        assert len(tools) == 1
+        assert tools[0].tags == {"example", "test-tag"}
+
+
+class TestResourceDecorator:
+    async def test_no_resources_before_decorator(self):
+        mcp = FastMCP()
+
+        with pytest.raises(ResourceError, match="Unknown resource"):
+            await mcp.read_resource("resource://data")
+
+    async def test_resource_decorator(self):
+        mcp = FastMCP()
+
+        @mcp.resource("resource://data")
+        def get_data() -> str:
+            return "Hello, world!"
+
+        result = await mcp.read_resource("resource://data")
+        assert result == "Hello, world!"
+
+    async def test_resource_decorator_incorrect_usage(self):
         mcp = FastMCP()
 
         with pytest.raises(
@@ -91,8 +230,386 @@ class TestCreateServer:
         ):
 
             @mcp.resource  # Missing parentheses #type: ignore
-            def get_data(x: str) -> str:
-                return f"Data: {x}"
+            def get_data() -> str:
+                return "Hello, world!"
+
+    async def test_resource_decorator_with_name(self):
+        mcp = FastMCP()
+
+        @mcp.resource("resource://data", name="custom-data")
+        def get_data() -> str:
+            return "Hello, world!"
+
+        resources = mcp.list_resources()
+        assert len(resources) == 1
+        assert resources[0].name == "custom-data"
+
+        result = await mcp.read_resource("resource://data")
+        assert result == "Hello, world!"
+
+    async def test_resource_decorator_with_description(self):
+        mcp = FastMCP()
+
+        @mcp.resource("resource://data", description="Data resource")
+        def get_data() -> str:
+            return "Hello, world!"
+
+        resources = mcp.list_resources()
+        assert len(resources) == 1
+        assert resources[0].description == "Data resource"
+
+    async def test_resource_decorator_instance_method(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            def __init__(self, prefix: str):
+                self.prefix = prefix
+
+            def get_data(self) -> str:
+                return f"{self.prefix} Hello, world!"
+
+        obj = MyClass("My prefix:")
+        mcp.add_resource_from_fn(
+            obj.get_data, uri="resource://data", name="instance-resource"
+        )
+
+        result = await mcp.read_resource("resource://data")
+        assert result == "My prefix: Hello, world!"
+
+    async def test_resource_decorator_classmethod(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            prefix = "Class prefix:"
+
+            @classmethod
+            def get_data(cls) -> str:
+                return f"{cls.prefix} Hello, world!"
+
+        mcp.add_resource_from_fn(
+            MyClass.get_data, uri="resource://data", name="class-resource"
+        )
+
+        result = await mcp.read_resource("resource://data")
+        assert result == "Class prefix: Hello, world!"
+
+    async def test_resource_decorator_staticmethod(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            @staticmethod
+            @mcp.resource("resource://data")
+            def get_data() -> str:
+                return "Static Hello, world!"
+
+        result = await mcp.read_resource("resource://data")
+        assert result == "Static Hello, world!"
+
+    async def test_resource_decorator_async_function(self):
+        mcp = FastMCP()
+
+        @mcp.resource("resource://data")
+        async def get_data() -> str:
+            return "Async Hello, world!"
+
+        result = await mcp.read_resource("resource://data")
+        assert result == "Async Hello, world!"
+
+    async def test_resource_decorator_with_tags(self):
+        mcp = FastMCP()
+
+        @mcp.resource("resource://data", tags={"example", "test-tag"})
+        def get_data() -> str:
+            return "Hello, world!"
+
+        resources = mcp.list_resources()
+        assert len(resources) == 1
+        assert resources[0].tags == {"example", "test-tag"}
+
+
+class TestTemplateDecorator:
+    async def test_template_decorator(self):
+        mcp = FastMCP()
+
+        @mcp.resource("resource://{name}/data")
+        def get_data(name: str) -> str:
+            return f"Data for {name}"
+
+        templates = mcp.list_resource_templates()
+        assert len(templates) == 1
+        assert templates[0].uri_template == "resource://{name}/data"
+
+        result = await mcp.read_resource("resource://test/data")
+        assert result == "Data for test"
+
+    async def test_template_decorator_incorrect_usage(self):
+        mcp = FastMCP()
+
+        with pytest.raises(
+            TypeError, match="The @resource decorator was used incorrectly"
+        ):
+
+            @mcp.resource  # Missing parentheses #type: ignore
+            def get_data(name: str) -> str:
+                return f"Data for {name}"
+
+    async def test_template_decorator_with_name(self):
+        mcp = FastMCP()
+
+        @mcp.resource("resource://{name}/data", name="custom-template")
+        def get_data(name: str) -> str:
+            return f"Data for {name}"
+
+        templates = mcp.list_resource_templates()
+        assert len(templates) == 1
+        assert templates[0].name == "custom-template"
+
+        result = await mcp.read_resource("resource://test/data")
+        assert result == "Data for test"
+
+    async def test_template_decorator_with_description(self):
+        mcp = FastMCP()
+
+        @mcp.resource("resource://{name}/data", description="Template description")
+        def get_data(name: str) -> str:
+            return f"Data for {name}"
+
+        templates = mcp.list_resource_templates()
+        assert len(templates) == 1
+        assert templates[0].description == "Template description"
+
+    async def test_template_decorator_instance_method(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            def __init__(self, prefix: str):
+                self.prefix = prefix
+
+            def get_data(self, name: str) -> str:
+                return f"{self.prefix} Data for {name}"
+
+        obj = MyClass("My prefix:")
+
+        mcp.add_resource_from_fn(
+            obj.get_data, uri="resource://{name}/data", name="instance-template"
+        )
+
+        result = await mcp.read_resource("resource://test/data")
+        assert result == "My prefix: Data for test"
+
+    async def test_template_decorator_classmethod(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            prefix = "Class prefix:"
+
+            @classmethod
+            def get_data(cls, name: str) -> str:
+                return f"{cls.prefix} Data for {name}"
+
+        mcp.add_resource_from_fn(
+            MyClass.get_data, uri="resource://{name}/data", name="class-template"
+        )
+
+        result = await mcp.read_resource("resource://test/data")
+        assert result == "Class prefix: Data for test"
+
+    async def test_template_decorator_staticmethod(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            @staticmethod
+            @mcp.resource("resource://{name}/data")
+            def get_data(name: str) -> str:
+                return f"Static Data for {name}"
+
+        result = await mcp.read_resource("resource://test/data")
+        assert result == "Static Data for test"
+
+    async def test_template_decorator_async_function(self):
+        mcp = FastMCP()
+
+        @mcp.resource("resource://{name}/data")
+        async def get_data(name: str) -> str:
+            return f"Async Data for {name}"
+
+        result = await mcp.read_resource("resource://test/data")
+        assert result == "Async Data for test"
+
+    async def test_template_decorator_with_tags(self):
+        mcp = FastMCP()
+
+        @mcp.resource("resource://{name}/data", tags={"template", "test-tag"})
+        def get_data(name: str) -> str:
+            return f"Data for {name}"
+
+        templates = mcp.list_resource_templates()
+        assert len(templates) == 1
+        assert templates[0].tags == {"template", "test-tag"}
+
+
+class TestPromptDecorator:
+    async def test_prompt_decorator(self):
+        mcp = FastMCP()
+
+        @mcp.prompt()
+        def test_prompt() -> str:
+            return "Hello, world!"
+
+        prompts = mcp.list_prompts()
+        assert len(prompts) == 1
+        assert prompts[0].name == "test_prompt"
+
+        result = await mcp.get_prompt("test_prompt")
+        assert len(result) == 1
+        message = result[0]
+        assert isinstance(message.content, TextContent)
+        assert message.content.text == "Hello, world!"
+
+    async def test_prompt_decorator_incorrect_usage(self):
+        mcp = FastMCP()
+
+        with pytest.raises(
+            TypeError, match="The @prompt decorator was used incorrectly"
+        ):
+
+            @mcp.prompt  # Missing parentheses #type: ignore
+            def test_prompt() -> str:
+                return "Hello, world!"
+
+    async def test_prompt_decorator_with_name(self):
+        mcp = FastMCP()
+
+        @mcp.prompt(name="custom-prompt")
+        def test_prompt() -> str:
+            return "Hello, world!"
+
+        prompts = mcp.list_prompts()
+        assert len(prompts) == 1
+        assert prompts[0].name == "custom-prompt"
+
+        result = await mcp.get_prompt("custom-prompt")
+        assert len(result) == 1
+        message = result[0]
+        assert isinstance(message.content, TextContent)
+        assert message.content.text == "Hello, world!"
+
+    async def test_prompt_decorator_with_description(self):
+        mcp = FastMCP()
+
+        @mcp.prompt(description="Test prompt description")
+        def test_prompt() -> str:
+            return "Hello, world!"
+
+        prompts = mcp.list_prompts()
+        assert len(prompts) == 1
+        assert prompts[0].description == "Test prompt description"
+
+    async def test_prompt_decorator_with_parameters(self):
+        mcp = FastMCP()
+
+        @mcp.prompt()
+        def test_prompt(name: str, greeting: str = "Hello") -> str:
+            return f"{greeting}, {name}!"
+
+        prompts = mcp.list_prompts()
+        assert len(prompts) == 1
+        assert prompts[0].arguments is not None
+        assert len(prompts[0].arguments) == 2
+        assert prompts[0].arguments[0].name == "name"
+        assert prompts[0].arguments[0].required is True
+        assert prompts[0].arguments[1].name == "greeting"
+        assert prompts[0].arguments[1].required is False
+
+        result = await mcp.get_prompt("test_prompt", {"name": "World"})
+        assert len(result) == 1
+        message = result[0]
+        assert isinstance(message.content, TextContent)
+        assert message.content.text == "Hello, World!"
+
+        result = await mcp.get_prompt(
+            "test_prompt", {"name": "World", "greeting": "Hi"}
+        )
+        assert len(result) == 1
+        message = result[0]
+        assert isinstance(message.content, TextContent)
+        assert message.content.text == "Hi, World!"
+
+    async def test_prompt_decorator_instance_method(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            def __init__(self, prefix: str):
+                self.prefix = prefix
+
+            def test_prompt(self) -> str:
+                return f"{self.prefix} Hello, world!"
+
+        obj = MyClass("My prefix:")
+        mcp.add_prompt(obj.test_prompt, name="test_prompt")
+
+        result = await mcp.get_prompt("test_prompt")
+        assert len(result) == 1
+        message = result[0]
+        assert isinstance(message.content, TextContent)
+        assert message.content.text == "My prefix: Hello, world!"
+
+    async def test_prompt_decorator_classmethod(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            prefix = "Class prefix:"
+
+            @classmethod
+            def test_prompt(cls) -> str:
+                return f"{cls.prefix} Hello, world!"
+
+        mcp.add_prompt(MyClass.test_prompt, name="test_prompt")
+
+        result = await mcp.get_prompt("test_prompt")
+        assert len(result) == 1
+        message = result[0]
+        assert isinstance(message.content, TextContent)
+        assert message.content.text == "Class prefix: Hello, world!"
+
+    async def test_prompt_decorator_staticmethod(self):
+        mcp = FastMCP()
+
+        class MyClass:
+            @staticmethod
+            @mcp.prompt()
+            def test_prompt() -> str:
+                return "Static Hello, world!"
+
+        result = await mcp.get_prompt("test_prompt")
+        assert len(result) == 1
+        message = result[0]
+        assert isinstance(message.content, TextContent)
+        assert message.content.text == "Static Hello, world!"
+
+    async def test_prompt_decorator_async_function(self):
+        mcp = FastMCP()
+
+        @mcp.prompt()
+        async def test_prompt() -> str:
+            return "Async Hello, world!"
+
+        result = await mcp.get_prompt("test_prompt")
+        assert len(result) == 1
+        message = result[0]
+        assert isinstance(message.content, TextContent)
+        assert message.content.text == "Async Hello, world!"
+
+    async def test_prompt_decorator_with_tags(self):
+        mcp = FastMCP()
+
+        @mcp.prompt(tags={"example", "test-tag"})
+        def test_prompt() -> str:
+            return "Hello, world!"
+
+        prompts = mcp.list_prompts()
+        assert len(prompts) == 1
+        assert prompts[0].tags == {"example", "test-tag"}
 
 
 @pytest.fixture
@@ -136,10 +653,10 @@ def tool_server():
 
 class TestServerTools:
     async def test_add_tool_exists(self, tool_server: FastMCP):
-        assert "add" in [t.name for t in await tool_server.list_tools()]
+        assert "add" in [t.name for t in await tool_server._mcp_list_tools()]
 
     async def test_list_tools(self, tool_server: FastMCP):
-        assert len(await tool_server.list_tools()) == 6
+        assert len(await tool_server._mcp_list_tools()) == 6
 
     async def test_call_tool(self, tool_server: FastMCP):
         result = await tool_server.call_tool("add", {"x": 1, "y": 2})
@@ -236,7 +753,7 @@ class TestServerTools:
             """A greeting tool"""
             return f"Hello {title} {name}"
 
-        tools = await mcp.list_tools()
+        tools = await mcp._mcp_list_tools()
         assert len(tools) == 1
         tool = tools[0]
 
@@ -328,7 +845,7 @@ class TestServerResourceTemplates:
         parameters don't match"""
         mcp = FastMCP()
 
-        with pytest.raises(ValueError, match="Mismatch between URI parameters"):
+        with pytest.raises(ValueError, match="mismatch between URI parameters"):
 
             @mcp.resource("resource://data")
             def get_data_fn(param: str) -> str:
@@ -338,7 +855,7 @@ class TestServerResourceTemplates:
         """Test that a resource with URI parameters is automatically a template"""
         mcp = FastMCP()
 
-        with pytest.raises(ValueError, match="Mismatch between URI parameters"):
+        with pytest.raises(ValueError, match="mismatch between URI parameters"):
 
             @mcp.resource("resource://{param}")
             def get_data() -> str:
@@ -422,7 +939,7 @@ class TestServerResourceTemplates:
 
         # Should be registered as a template
         assert len(mcp._resource_manager._templates) == 1
-        assert len(await mcp.list_resources()) == 0
+        assert len(await mcp._mcp_list_resources()) == 0
 
         # When accessed, should create a concrete resource
         resource = await mcp._resource_manager.get_resource("resource://test/data")

tests/utilities/test_decorated_function.py

@@ -0,0 +1,222 @@
+import functools
+from collections.abc import Callable
+from typing import Any
+
+import pytest
+
+from fastmcp.utilities.decorators import DecoratedFunction
+
+DECORATOR_CALLED = []
+
+
+def decorator(fn: Callable[..., Any]) -> DecoratedFunction[..., Any]:
+    @functools.wraps(fn)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        DECORATOR_CALLED.append((args, kwargs))
+        return fn(*args, **kwargs)
+
+    return DecoratedFunction(wrapper)
+
+
+@pytest.fixture(autouse=True)
+def reset_decorator_called():
+    DECORATOR_CALLED.clear()
+    yield
+    DECORATOR_CALLED.clear()
+
+
+@decorator
+def add(a: int, b: int) -> int:
+    return a + b
+
+
+@decorator
+async def add_async(a: int, b: int) -> int:
+    return a + b
+
+
+class DecoratedClass:
+    def __init__(self, x: int):
+        self.x = x
+
+    @decorator
+    def add(self, a: int, b: int) -> int:
+        return a + b + self.x
+
+    @decorator
+    async def add_async(self, a: int, b: int) -> int:
+        return a + b + self.x
+
+    @classmethod
+    @decorator
+    def add_classmethod(cls, a: int, b: int) -> int:
+        return a + b
+
+    @staticmethod
+    @decorator
+    def add_staticmethod(a: int, b: int) -> int:
+        return a + b
+
+    @classmethod
+    @decorator
+    async def add_classmethod_async(cls, a: int, b: int) -> int:
+        return a + b
+
+    @staticmethod
+    @decorator
+    async def add_staticmethod_async(a: int, b: int) -> int:
+        return a + b
+
+    @decorator
+    @classmethod
+    def add_classmethod_reverse_decorator_order(cls, a: int, b: int) -> int:
+        return a + b
+
+    @decorator
+    @staticmethod
+    def add_staticmethod_reverse_decorator_order(a: int, b: int) -> int:
+        return a + b
+
+    @decorator
+    @classmethod
+    async def add_classmethod_async_reverse_decorator_order(cls, a: int, b: int) -> int:
+        return a + b
+
+    @decorator
+    @staticmethod
+    async def add_staticmethod_async_reverse_decorator_order(a: int, b: int) -> int:
+        return a + b
+
+
+def test_add():
+    assert add(1, 2) == 3
+    assert DECORATOR_CALLED == [((1, 2), {})]
+    DECORATOR_CALLED.clear()
+
+    # Test with keyword arguments
+    assert add(a=3, b=4) == 7
+    assert DECORATOR_CALLED == [((), {"a": 3, "b": 4})]
+
+
+async def test_add_async():
+    assert await add_async(1, 2) == 3
+    assert DECORATOR_CALLED == [((1, 2), {})]
+    DECORATOR_CALLED.clear()
+
+    # Test with keyword arguments
+    assert await add_async(a=3, b=4) == 7
+    assert DECORATOR_CALLED == [((), {"a": 3, "b": 4})]
+
+
+def test_instance_method():
+    obj = DecoratedClass(10)
+    assert obj.add(2, 3) == 15
+    assert DECORATOR_CALLED == [((obj, 2, 3), {})]
+    DECORATOR_CALLED.clear()
+
+    # Test with keyword arguments
+    assert obj.add(a=4, b=5) == 19
+    assert DECORATOR_CALLED == [((obj,), {"a": 4, "b": 5})]
+
+
+async def test_instance_method_async():
+    obj = DecoratedClass(10)
+    assert await obj.add_async(2, 3) == 15
+    assert DECORATOR_CALLED == [((obj, 2, 3), {})]
+    DECORATOR_CALLED.clear()
+
+    # Test with keyword arguments
+    assert await obj.add_async(a=4, b=5) == 19
+    assert DECORATOR_CALLED == [((obj,), {"a": 4, "b": 5})]
+
+
+def test_classmethod():
+    assert DecoratedClass.add_classmethod(1, 2) == 3
+    assert DECORATOR_CALLED == [((DecoratedClass, 1, 2), {})]
+    DECORATOR_CALLED.clear()
+
+    # Test with keyword arguments
+    assert DecoratedClass.add_classmethod(a=3, b=4) == 7
+    assert DECORATOR_CALLED == [((DecoratedClass,), {"a": 3, "b": 4})]
+    DECORATOR_CALLED.clear()
+
+    # Test via instance
+    obj = DecoratedClass(10)
+    assert obj.add_classmethod(5, 6) == 11
+    assert DECORATOR_CALLED == [((DecoratedClass, 5, 6), {})]
+
+
+async def test_classmethod_async():
+    assert await DecoratedClass.add_classmethod_async(1, 2) == 3
+    assert DECORATOR_CALLED == [((DecoratedClass, 1, 2), {})]
+    DECORATOR_CALLED.clear()
+
+    # Test with keyword arguments
+    assert await DecoratedClass.add_classmethod_async(a=3, b=4) == 7
+    assert DECORATOR_CALLED == [((DecoratedClass,), {"a": 3, "b": 4})]
+    DECORATOR_CALLED.clear()
+
+    # Test via instance
+    obj = DecoratedClass(10)
+    assert await obj.add_classmethod_async(5, 6) == 11
+    assert DECORATOR_CALLED == [((DecoratedClass, 5, 6), {})]
+
+
+def test_classmethod_wrong_order():
+    with pytest.raises(
+        TypeError,
+        match="To apply this decorator to a classmethod, apply the decorator first, then @classmethod on top.",
+    ):
+        DecoratedClass.add_classmethod_reverse_decorator_order(1, 2)
+
+
+async def test_classmethod_async_wrong_order():
+    with pytest.raises(
+        TypeError,
+        match="To apply this decorator to a classmethod, apply the decorator first, then @classmethod on top.",
+    ):
+        await DecoratedClass.add_classmethod_async_reverse_decorator_order(1, 2)
+
+
+def test_staticmethod():
+    assert DecoratedClass.add_staticmethod(1, 2) == 3
+    assert DECORATOR_CALLED == [((1, 2), {})]
+    DECORATOR_CALLED.clear()
+
+    # Test with keyword arguments
+    assert DecoratedClass.add_staticmethod(a=3, b=4) == 7
+    assert DECORATOR_CALLED == [((), {"a": 3, "b": 4})]
+    DECORATOR_CALLED.clear()
+
+    # Test via instance
+    obj = DecoratedClass(10)
+    assert obj.add_staticmethod(5, 6) == 11
+    assert DECORATOR_CALLED == [((5, 6), {})]
+
+
+async def test_staticmethod_async():
+    assert await DecoratedClass.add_staticmethod_async(1, 2) == 3
+    assert DECORATOR_CALLED == [((1, 2), {})]
+    DECORATOR_CALLED.clear()
+
+    # Test with keyword arguments
+    assert await DecoratedClass.add_staticmethod_async(a=3, b=4) == 7
+    assert DECORATOR_CALLED == [((), {"a": 3, "b": 4})]
+    DECORATOR_CALLED.clear()
+
+    # Test via instance
+    obj = DecoratedClass(10)
+    assert await obj.add_staticmethod_async(5, 6) == 11
+    assert DECORATOR_CALLED == [((5, 6), {})]
+
+
+def test_staticmethod_wrong_order():
+    assert DecoratedClass.add_staticmethod_reverse_decorator_order(1, 2) == 3
+    assert DECORATOR_CALLED == [((1, 2), {})]
+
+
+async def test_staticmethod_async_wrong_order():
+    assert (
+        await DecoratedClass.add_staticmethod_async_reverse_decorator_order(1, 2) == 3
+    )
+    assert DECORATOR_CALLED == [((1, 2), {})]