feat: add structured capability types

Replace generic capability dictionaries with structured types for prompts,
resources, tools, and roots. This improves type safety and makes capability
features like listChanged and subscribe more explicit in the protocol.

Author: dsp-ant

mcp_python/__init__.py

@@ -33,10 +33,13 @@
     Notification,
     PingRequest,
     ProgressNotification,
+    PromptsCapability,
     ReadResourceRequest,
     ReadResourceResult,
     Resource,
+    ResourcesCapability,
     ResourceUpdatedNotification,
+    RootsCapability,
     SamplingMessage,
     ServerCapabilities,
     ServerNotification,
@@ -46,6 +49,7 @@
     StopReason,
     SubscribeRequest,
     Tool,
+    ToolsCapability,
     UnsubscribeRequest,
 )
 from .types import (
@@ -82,10 +86,13 @@
     "Notification",
     "PingRequest",
     "ProgressNotification",
+    "PromptsCapability",
     "ReadResourceRequest",
     "ReadResourceResult",
+    "ResourcesCapability",
     "ResourceUpdatedNotification",
     "Resource",
+    "RootsCapability",
     "SamplingMessage",
     "SamplingRole",
     "ServerCapabilities",
@@ -98,6 +105,7 @@
     "StopReason",
     "SubscribeRequest",
     "Tool",
+    "ToolsCapability",
     "UnsubscribeRequest",
     "stdio_client",
     "stdio_server",

mcp_python/server/__init__.py

@@ -27,20 +27,24 @@
     ListResourcesResult,
     ListToolsRequest,
     ListToolsResult,
+    LoggingCapability,
     LoggingLevel,
     PingRequest,
     ProgressNotification,
     Prompt,
     PromptReference,
+    PromptsCapability,
     ReadResourceRequest,
     ReadResourceResult,
     Resource,
     ResourceReference,
+    ResourcesCapability,
     ServerCapabilities,
     ServerResult,
     SetLevelRequest,
     SubscribeRequest,
     Tool,
+    ToolsCapability,
     UnsubscribeRequest,
 )
 
@@ -84,14 +88,14 @@ def pkg_version(package: str) -> str:
     def get_capabilities(self) -> ServerCapabilities:
         """Convert existing handlers to a ServerCapabilities object."""
 
-        def get_capability(req_type: type) -> dict[str, Any] | None:
-            return {} if req_type in self.request_handlers else None
+        def has_capability(req_type: type) -> bool:
+            return req_type in self.request_handlers
 
         return ServerCapabilities(
-            prompts=get_capability(ListPromptsRequest),
-            resources=get_capability(ListResourcesRequest),
-            tools=get_capability(ListToolsRequest),
-            logging=get_capability(SetLevelRequest),
+            prompts=PromptsCapability(listChanged=False) if has_capability(ListPromptsRequest) else None,
+            resources=ResourcesCapability(subscribe=False, listChanged=False) if has_capability(ListResourcesRequest) else None,
+            tools=ToolsCapability(listChanged=False) if has_capability(ListToolsRequest) else None,
+            logging=LoggingCapability() if has_capability(SetLevelRequest) else None,
         )
 
     @property

mcp_python/types.py

@@ -184,28 +184,65 @@ class Implementation(BaseModel):
     model_config = ConfigDict(extra="allow")
 
 
+class RootsCapability(BaseModel):
+    """Capability for root operations."""
+    listChanged: bool | None = None
+    """Whether the client supports notifications for changes to the roots list."""
+    model_config = ConfigDict(extra="allow")
+
+
 class ClientCapabilities(BaseModel):
     """Capabilities a client may support."""
 
     experimental: dict[str, dict[str, Any]] | None = None
     """Experimental, non-standard capabilities that the client supports."""
     sampling: dict[str, Any] | None = None
     """Present if the client supports sampling from an LLM."""
+    roots: RootsCapability | None = None
+    """Present if the client supports listing roots."""
+    model_config = ConfigDict(extra="allow")
+
+
+class PromptsCapability(BaseModel):
+    """Capability for prompts operations."""
+    listChanged: bool | None = None
+    """Whether this server supports notifications for changes to the prompt list."""
     model_config = ConfigDict(extra="allow")
 
 
+class ResourcesCapability(BaseModel):
+    """Capability for resources operations."""
+    subscribe: bool | None = None
+    """Whether this server supports subscribing to resource updates."""
+    listChanged: bool | None = None
+    """Whether this server supports notifications for changes to the resource list."""
+    model_config = ConfigDict(extra="allow")
+
+
+class ToolsCapability(BaseModel):
+    """Capability for tools operations."""
+    listChanged: bool | None = None
+    """Whether this server supports notifications for changes to the tool list."""
+    model_config = ConfigDict(extra="allow")
+
+
+class LoggingCapability(BaseModel):
+    """Capability for logging operations."""
+    pass
+
+
 class ServerCapabilities(BaseModel):
     """Capabilities that a server may support."""
 
     experimental: dict[str, dict[str, Any]] | None = None
     """Experimental, non-standard capabilities that the server supports."""
-    logging: dict[str, Any] | None = None
+    logging: LoggingCapability | None = None
     """Present if the server supports sending log messages to the client."""
-    prompts: dict[str, Any] | None = None
+    prompts: PromptsCapability | None = None
     """Present if the server offers any prompt templates."""
-    resources: dict[str, Any] | None = None
+    resources: ResourcesCapability | None = None
     """Present if the server offers any resources to read."""
-    tools: dict[str, Any] | None = None
+    tools: ToolsCapability | None = None
     """Present if the server offers any tools to call."""
     model_config = ConfigDict(extra="allow")