Allow passing initialization options to a session

We need a way for servers to pass initialization options to the session.
This is the beginning of this.

Author: dsp-ant

mcp_python/server/__init__.py

@@ -2,13 +2,13 @@
 import logging
 import warnings
 from collections.abc import Awaitable, Callable
-from typing import Any
+from typing import Any, Self
 
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from pydantic import AnyUrl
 
 from mcp_python.server import types
-from mcp_python.server.session import ServerSession
+from mcp_python.server.session import ServerSession, SessionInitializationOptions
 from mcp_python.server.stdio import stdio_server as stdio_server
 from mcp_python.shared.context import RequestContext
 from mcp_python.shared.session import RequestResponder
@@ -32,6 +32,7 @@
     ReadResourceResult,
     Resource,
     ResourceReference,
+    ServerCapabilities,
     ServerResult,
     SetLevelRequest,
     SubscribeRequest,
@@ -40,11 +41,27 @@
 
 logger = logging.getLogger(__name__)
 
-
 request_ctx: contextvars.ContextVar[RequestContext] = contextvars.ContextVar(
     "request_ctx"
 )
 
+def pkg_version(package: str) -> str:
+    try:
+        from importlib.metadata import version
+        return version(package)
+    except Exception:
+        return "unknown"
+
+class InitializationOptions(SessionInitializationOptions):
+    """Information about a server provided as initialization options when a new session is started."""
+
+    @classmethod
+    def from_server(cls, server: "Server") -> Self:
+        return cls(
+            server_name=server.name,
+            server_version=pkg_version("mcp_python"),
+            capabilities=server.get_capabilities()
+        )
 
 class Server:
     def __init__(self, name: str):
@@ -276,13 +293,26 @@ async def handler(req: CompleteRequest):
 
         return decorator
 
+    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
+
+        return ServerCapabilities(
+            prompts=get_capability(ListPromptsRequest),
+            resources=get_capability(ListResourcesRequest),
+            tools=get_capability(ListPromptsRequest),
+            logging=get_capability(SetLevelRequest)
+        )
+
     async def run(
         self,
         read_stream: MemoryObjectReceiveStream[JSONRPCMessage | Exception],
         write_stream: MemoryObjectSendStream[JSONRPCMessage],
+        initialization_options: InitializationOptions
     ):
         with warnings.catch_warnings(record=True) as w:
-            async with ServerSession(read_stream, write_stream) as session:
+            async with ServerSession(read_stream, write_stream, initialization_options) as session:
                 async for message in session.incoming_messages:
                     logger.debug(f"Received message: {message}")
 

mcp_python/server/__main__.py

@@ -1,10 +1,11 @@
 import logging
 import sys
-
+import importlib.metadata
 import anyio
 
-from mcp_python.server.session import ServerSession
+from mcp_python.server.session import SessionInitializationOptions, ServerSession
 from mcp_python.server.stdio import stdio_server
+from mcp_python.types import ServerCapabilities
 
 if not sys.warnoptions:
     import warnings
@@ -26,8 +27,9 @@ async def receive_loop(session: ServerSession):
 
 
 async def main():
+    version = importlib.metadata.version("mcp_python")
     async with stdio_server() as (read_stream, write_stream):
-        async with ServerSession(read_stream, write_stream) as session, write_stream:
+        async with ServerSession(read_stream, write_stream, SessionInitializationOptions(server_name="mcp_python", server_version=version, capabilities=ServerCapabilities())) as session, write_stream:
             await receive_loop(session)
 
 

mcp_python/server/session.py

@@ -4,7 +4,7 @@
 import anyio
 import anyio.lowlevel
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-from pydantic import AnyUrl
+from pydantic import AnyUrl, BaseModel
 
 from mcp_python.shared.session import (
     BaseSession,
@@ -37,6 +37,13 @@ class InitializationState(Enum):
     Initialized = 3
 
 
+class SessionInitializationOptions(BaseModel):
+    server_name: str
+    server_version: str
+    capabilities: ServerCapabilities
+
+
+
 class ServerSession(
     BaseSession[
         ServerRequest,
@@ -52,9 +59,11 @@ def __init__(
         self,
         read_stream: MemoryObjectReceiveStream[JSONRPCMessage | Exception],
         write_stream: MemoryObjectSendStream[JSONRPCMessage],
+        init_options: SessionInitializationOptions
     ) -> None:
         super().__init__(read_stream, write_stream, ClientRequest, ClientNotification)
         self._initialization_state = InitializationState.NotInitialized
+        self._init_options = init_options
 
     async def _received_request(
         self, responder: RequestResponder[ClientRequest, ServerResult]
@@ -66,15 +75,10 @@ async def _received_request(
                     ServerResult(
                         InitializeResult(
                             protocolVersion=SUPPORTED_PROTOCOL_VERSION,
-                            capabilities=ServerCapabilities(
-                                logging=None,
-                                resources=None,
-                                tools=None,
-                                experimental=None,
-                                prompts={},
-                            ),
+                            capabilities=self._init_options.capabilities,
                             serverInfo=Implementation(
-                                name="mcp_python", version="0.1.0"
+                                name=self._init_options.server_name,
+                                version=self._init_options.server_version
                             ),
                         )
                     )

pyproject.toml

@@ -35,3 +35,8 @@ target-version = "py38"
 
 [tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["F401"]
+
+[tool.uv]
+dev-dependencies = [
+    "trio>=0.26.2",
+]

tests/server/test_session.py

@@ -2,11 +2,13 @@
 import pytest
 
 from mcp_python.client.session import ClientSession
-from mcp_python.server.session import ServerSession
+from mcp_python.server import Server
+from mcp_python.server.session import ServerSession, SessionInitializationOptions
 from mcp_python.types import (
     ClientNotification,
     InitializedNotification,
     JSONRPCMessage,
+    ServerCapabilities,
 )
 
 
@@ -30,7 +32,7 @@ async def run_server():
         nonlocal received_initialized
 
         async with ServerSession(
-            client_to_server_receive, server_to_client_send
+            client_to_server_receive, server_to_client_send, SessionInitializationOptions(server_name='mcp_python', server_version='0.1.0', capabilities=ServerCapabilities())
         ) as server_session:
             async for message in server_session.incoming_messages:
                 if isinstance(message, Exception):
@@ -57,3 +59,31 @@ async def run_server():
         pass
 
     assert received_initialized
+
+
+@pytest.mark.anyio
+async def test_server_capabilities():
+    server = Server("test")
+
+    # Initially no capabilities
+    caps = server.get_capabilities()
+    assert caps.prompts is None
+    assert caps.resources is None
+
+    # Add a prompts handler
+    @server.list_prompts()
+    async def list_prompts():
+        return []
+
+    caps = server.get_capabilities()
+    assert caps.prompts == {}
+    assert caps.resources is None
+
+    # Add a resources handler
+    @server.list_resources()
+    async def list_resources():
+        return []
+
+    caps = server.get_capabilities()
+    assert caps.prompts == {}
+    assert caps.resources == {}