feat: implement resource-based inheritance for tools and prompts

Add ToolResource and PromptResource base classes that extend the Resource
base class. Tool now inherits from ToolResource and Prompt inherits from
PromptResource, establishing a proper inheritance hierarchy.

Tools and prompts automatically generate URIs with their respective schemes
(tool://name and prompt://name) when created. This allows them to be accessed
through the ResourceManager using their URIs while maintaining full backward
compatibility with existing code.

The ResourceManager's list_resources() method filters out tool and prompt
URIs by default to preserve the existing API behavior. Tools and prompts
can still be accessed directly by their URIs when needed.

Comprehensive tests verify the inheritance model works correctly and that
all existing functionality remains intact.

Author: Tapan Chugh

src/mcp/server/fastmcp/prompts/base.py

@@ -1,12 +1,14 @@
 """Base classes for FastMCP prompts."""
 
 import inspect
+import json
 from collections.abc import Awaitable, Callable, Sequence
 from typing import Any, Literal
 
 import pydantic_core
 from pydantic import BaseModel, Field, TypeAdapter, validate_call
 
+from mcp.server.fastmcp.resources import PromptResource
 from mcp.types import ContentBlock, TextContent
 
 
@@ -54,12 +56,9 @@ class PromptArgument(BaseModel):
     required: bool = Field(default=False, description="Whether the argument is required")
 
 
-class Prompt(BaseModel):
+class Prompt(PromptResource):
     """A prompt template that can be rendered with parameters."""
 
-    name: str = Field(description="Name of the prompt")
-    title: str | None = Field(None, description="Human-readable title of the prompt")
-    description: str | None = Field(None, description="Description of what the prompt does")
     arguments: list[PromptArgument] | None = Field(None, description="Arguments that can be passed to the prompt")
     fn: Callable[..., PromptResult | Awaitable[PromptResult]] = Field(exclude=True)
 
@@ -111,6 +110,28 @@ def from_function(
             fn=fn,
         )
 
+    async def read(self) -> str | bytes:
+        """Read the prompt template/documentation as JSON."""
+        prompt_info: dict[str, Any] = {
+            "name": self.name,
+            "title": self.title,
+            "description": self.description,
+            "uri": str(self.uri),
+        }
+
+        # Include arguments if available
+        if self.arguments:
+            prompt_info["arguments"] = [
+                {
+                    "name": arg.name,
+                    "description": arg.description,
+                    "required": arg.required,
+                }
+                for arg in self.arguments
+            ]
+
+        return json.dumps(prompt_info, indent=2)
+
     async def render(self, arguments: dict[str, Any] | None = None) -> list[Message]:
         """Render the prompt with arguments."""
         # Validate required arguments

src/mcp/server/fastmcp/resources/__init__.py

@@ -1,6 +1,8 @@
 from .base import Resource
+from .prompt_resource import PromptResource
 from .resource_manager import ResourceManager
 from .templates import ResourceTemplate
+from .tool_resource import ToolResource
 from .types import (
     BinaryResource,
     DirectoryResource,
@@ -20,4 +22,6 @@
     "DirectoryResource",
     "ResourceTemplate",
     "ResourceManager",
+    "ToolResource",
+    "PromptResource",
 ]

src/mcp/server/fastmcp/resources/prompt_resource.py

@@ -0,0 +1,37 @@
+"""Prompt resource base class."""
+
+import json
+from typing import Any
+
+from pydantic import AnyUrl, Field
+
+from mcp.server.fastmcp.resources.base import Resource
+
+
+class PromptResource(Resource):
+    """Base class for prompts that are also resources."""
+
+    # Override mime_type default for prompts
+    mime_type: str = Field(
+        default="application/json",
+        description="MIME type of the resource content",
+        pattern=r"^[a-zA-Z0-9]+/[a-zA-Z0-9\-+.]+$",
+    )
+
+    def __init__(self, **data: Any):
+        # Auto-generate URI if not provided
+        if "uri" not in data and "name" in data:
+            data["uri"] = AnyUrl(f"prompt://{data['name']}")
+        super().__init__(**data)
+
+    async def read(self) -> str | bytes:
+        """Read the prompt template/documentation as JSON."""
+        # This will be overridden by the Prompt class
+        return json.dumps(
+            {
+                "name": self.name,
+                "title": self.title,
+                "description": self.description,
+                "uri": str(self.uri),
+            }
+        )

src/mcp/server/fastmcp/resources/resource_manager.py

@@ -87,11 +87,30 @@ async def get_resource(self, uri: AnyUrl | str) -> Resource | None:
         raise ValueError(f"Unknown resource: {uri}")
 
     def list_resources(self, prefix: str | None = None) -> list[Resource]:
-        """List all registered resources, optionally filtered by URI prefix."""
-        resources = list(self._resources.values())
+        """List all registered resources, optionally filtered by URI prefix.
+        
+        Note: Tool and prompt resources (with tool:// and prompt:// URIs) are excluded
+        by default to maintain API compatibility.
+        """
+        all_resources = list(self._resources.values())
+        
+        # Filter out tool and prompt resources to maintain API compatibility
+        resources = [
+            r for r in all_resources if not (str(r.uri).startswith("tool://") or str(r.uri).startswith("prompt://"))
+        ]
+        
+        # Apply prefix filter if provided
         if prefix:
             resources = [r for r in resources if str(r.uri).startswith(prefix)]
-        logger.debug("Listing resources", extra={"count": len(resources), "prefix": prefix})
+            
+        logger.debug(
+            "Listing resources", 
+            extra={
+                "total_count": len(all_resources), 
+                "filtered_count": len(resources),
+                "prefix": prefix
+            }
+        )
         return resources
 
     def list_templates(self, prefix: str | None = None) -> list[ResourceTemplate]:

src/mcp/server/fastmcp/resources/tool_resource.py

@@ -0,0 +1,37 @@
+"""Tool resource base class."""
+
+import json
+from typing import Any
+
+from pydantic import AnyUrl, Field
+
+from mcp.server.fastmcp.resources.base import Resource
+
+
+class ToolResource(Resource):
+    """Base class for tools that are also resources."""
+
+    # Override mime_type default for tools
+    mime_type: str = Field(
+        default="application/json",
+        description="MIME type of the resource content",
+        pattern=r"^[a-zA-Z0-9]+/[a-zA-Z0-9\-+.]+$",
+    )
+
+    def __init__(self, **data: Any):
+        # Auto-generate URI if not provided
+        if "uri" not in data and "name" in data:
+            data["uri"] = AnyUrl(f"tool://{data['name']}")
+        super().__init__(**data)
+
+    async def read(self) -> str | bytes:
+        """Read the tool schema/documentation as JSON."""
+        # This will be overridden by the Tool class
+        return json.dumps(
+            {
+                "name": self.name,
+                "title": self.title,
+                "description": self.description,
+                "uri": str(self.uri),
+            }
+        )

src/mcp/server/fastmcp/tools/base.py

@@ -2,13 +2,15 @@
 
 import functools
 import inspect
+import json
 from collections.abc import Callable
 from functools import cached_property
 from typing import TYPE_CHECKING, Any, get_origin
 
-from pydantic import BaseModel, Field
+from pydantic import Field
 
 from mcp.server.fastmcp.exceptions import ToolError
+from mcp.server.fastmcp.resources import ToolResource
 from mcp.server.fastmcp.utilities.func_metadata import FuncMetadata, func_metadata
 from mcp.types import ToolAnnotations
 
@@ -18,13 +20,10 @@
     from mcp.shared.context import LifespanContextT, RequestT
 
 
-class Tool(BaseModel):
+class Tool(ToolResource):
     """Internal tool registration info."""
 
     fn: Callable[..., Any] = Field(exclude=True)
-    name: str = Field(description="Name of the tool")
-    title: str | None = Field(None, description="Human-readable title of the tool")
-    description: str = Field(description="Description of what the tool does")
     parameters: dict[str, Any] = Field(description="JSON schema for tool parameters")
     fn_metadata: FuncMetadata = Field(
         description="Metadata about the function including a pydantic model for tool arguments"
@@ -87,6 +86,26 @@ def from_function(
             annotations=annotations,
         )
 
+    async def read(self) -> str | bytes:
+        """Read the tool schema/documentation as JSON."""
+        tool_info = {
+            "name": self.name,
+            "title": self.title,
+            "description": self.description,
+            "uri": str(self.uri),
+            "parameters": self.parameters,
+        }
+
+        # Include output schema if available
+        if self.output_schema:
+            tool_info["output_schema"] = self.output_schema
+
+        # Include annotations if available
+        if self.annotations:
+            tool_info["annotations"] = self.annotations.model_dump(exclude_none=True)
+
+        return json.dumps(tool_info, indent=2)
+
     async def run(
         self,
         arguments: dict[str, Any],