π The fast, Pythonic way to build MCP servers and clients.
Expose era-neutral client server metadata (#4599)
nate nowack06aa84943c3d
diff --git a/docs/clients/client.mdx b/docs/clients/client.mdxindex 1024984c7..973043455 100644--- a/docs/clients/client.mdx+++ b/docs/clients/client.mdx@@ -123,7 +123,7 @@ async with client:## Connection Lifecycle-The client uses context managers for connection management. When you enter the context, the client establishes a connection and performs an MCP initialization handshake with the server. This handshake exchanges capabilities, server metadata, and instructions.+The client uses context managers for connection management. When you enter the context, the client establishes a connection and negotiates the protocol era with the server. Metadata returned by either legacy initialization or modern discovery is exposed through the same client properties.```pythonfrom fastmcp import Client, FastMCP@@ -136,10 +136,12 @@ def greet(name: str) -> str:return f"Hello, {name}!"async with Client(mcp) as client:- # Initialization already happened automatically- print(f"Server: {client.initialize_result.server_info.name}")- print(f"Instructions: {client.initialize_result.instructions}")- print(f"Capabilities: {client.initialize_result.capabilities.tools}")+ # Protocol negotiation already happened automatically+ assert client.server_info is not None+ assert client.server_capabilities is not None+ print(f"Server: {client.server_info.name}")+ print(f"Instructions: {client.instructions}")+ print(f"Capabilities: {client.server_capabilities.tools}")```For advanced scenarios where you need precise control over when initialization happens, disable automatic initialization and call `initialize()` manually:@@ -199,12 +201,16 @@ You can also pin a specific modern protocol version to adopt it directly, withouclient = Client("https://example.com/mcp", mode="2026-07-28")```-Once connected, the negotiated version and the server's advertised capabilities are available as properties. Both are populated regardless of which era was negotiated, and both are `None` while the client is disconnected.+Once connected, the negotiated version, server identity, capabilities, and instructions are available as properties. They are populated from either the legacy `InitializeResult` or modern `DiscoverResult`, and reset to `None` when the client disconnects. `instructions` is also `None` when the server does not provide any.++When you pin a modern version directly, the client skips discovery and adopts that version with minimal synthesized metadata. In that mode, `server_info` has an empty name and `instructions` is `None`.```pythonasync with Client("https://example.com/mcp", mode="auto") as client:print(client.protocol_version) # e.g. "2026-07-28"+ print(client.server_info) # Implementation | Noneprint(client.server_capabilities) # ServerCapabilities | None+ print(client.instructions) # str | None```<Note>diff --git a/fastmcp_slim/fastmcp/client/client.py b/fastmcp_slim/fastmcp/client/client.pyindex c62429f29..50eb136b0 100644--- a/fastmcp_slim/fastmcp/client/client.py+++ b/fastmcp_slim/fastmcp/client/client.py@@ -643,8 +643,9 @@ class Client("""Get the result of the initialization request.`None` on a modern (`server/discover`) connection, which negotiates via a- `DiscoverResult` rather than an `InitializeResult`. Use `protocol_version` /- `server_capabilities` for era-neutral access to the negotiated identity.+ `DiscoverResult` rather than an `InitializeResult`. Use `protocol_version`,+ `server_info`, `server_capabilities`, and `instructions` for era-neutral+ access to the negotiated server metadata."""return self._session_state.initialize_result@@ -668,6 +669,27 @@ class Client(session = self._session_state.sessionreturn session.server_capabilities if session is not None else None+ @property+ def server_info(self) -> mcp_types.Implementation | None:+ """The session's server identity, or `None` when disconnected.++ Populated from whichever negotiation result the era produced (the+ `InitializeResult` on legacy, the `DiscoverResult` on modern). A directly+ pinned modern version uses a synthesized identity with an empty name.+ """+ session = self._session_state.session+ return session.server_info if session is not None else None++ @property+ def instructions(self) -> str | None:+ """The server's instructions, or `None` when absent or disconnected.++ Populated from whichever negotiation result the era produced (the+ `InitializeResult` on legacy, the `DiscoverResult` on modern).+ """+ session = self._session_state.session+ return session.instructions if session is not None else None+def set_roots(self, roots: RootsList | RootsHandler) -> None:"""Set the roots for the client. This does not automatically call `send_roots_list_changed`."""self._session_kwargs["list_roots_callback"] = create_roots_callback(roots)@@ -853,8 +875,9 @@ class Client(With `mode="auto"` or a pinned modern version, connect-time negotiation may adoptthe modern `server/discover` era, which has no `InitializeResult`; in that case- this method raises. Read `protocol_version` / `server_capabilities` instead, or use- `mode="legacy"` when you need the handshake result.+ this method raises. Read `protocol_version`, `server_info`,+ `server_capabilities`, and `instructions` instead, or use `mode="legacy"`+ when you need the handshake result.Args:timeout: Optional timeout for the initialization request (seconds or timedelta).@@ -887,8 +910,9 @@ class Client(if self.initialize_result is None:raise RuntimeError("The client negotiated a modern protocol era (server/discover), which has "- "no InitializeResult. Read client.protocol_version / client.server_capabilities "- "instead, or construct the client with mode='legacy'."+ "no InitializeResult. Inspect client.protocol_version, client.server_info, "+ "client.server_capabilities, and client.instructions for the metadata "+ "available in this mode, or construct the client with mode='legacy'.")return self.initialize_resultdiff --git a/tests/client/client/test_mode_negotiation.py b/tests/client/client/test_mode_negotiation.pyindex 37eb96075..66904d2ee 100644--- a/tests/client/client/test_mode_negotiation.py+++ b/tests/client/client/test_mode_negotiation.py@@ -248,6 +248,9 @@ class TestPinnedMode:async with Client(fastmcp_server, mode=LATEST_MODERN_VERSION) as client:assert client.protocol_version == LATEST_MODERN_VERSIONassert client.initialize_result is None+ assert client.server_info is not None+ assert client.server_info.name == ""+ assert client.instructions is Noneasync def test_pinned_modern_call_tool(self, fastmcp_server):async with Client(fastmcp_server, mode=LATEST_MODERN_VERSION) as client:@@ -256,10 +259,20 @@ class TestPinnedMode:class TestConnectionProperties:+ @pytest.mark.parametrize("mode", ["legacy", "auto"])+ async def test_server_metadata_available_across_eras(self, mode):+ server = FastMCP("MetadataServer", instructions="Use the metadata tools.")+ async with Client(server, mode=mode) as client:+ assert client.server_info is not None+ assert client.server_info.name == "MetadataServer"+ assert client.instructions == "Use the metadata tools."+async def test_properties_none_before_connect(self, fastmcp_server):client = Client(fastmcp_server, mode="auto")assert client.protocol_version is Noneassert client.server_capabilities is None+ assert client.server_info is None+ assert client.instructions is Noneasync def test_properties_none_after_disconnect(self, fastmcp_server):client = Client(fastmcp_server, mode="auto")@@ -267,6 +280,8 @@ class TestConnectionProperties:assert client.protocol_version is not Noneassert client.protocol_version is Noneassert client.server_capabilities is None+ assert client.server_info is None+ assert client.instructions is Noneclass TestManualNegotiation: