simplify(client): collapse to single initialize_result proxy

- Remove _initialize_result captured state (tracked same invariant as _session)
- Remove server_capabilities/server_info/server_instructions decomposed properties
- Client.initialize_result proxies through session, non-nullable
- Unreachable None branch marked pragma: no cover (self.session raises first)

server_capabilities had no organic usage beyond a did-init-happen probe;
every other result type (CallToolResult, etc.) comes back whole.

Github-Issue: #1018

Author: maxisbey

docs/migration.md

@@ -191,7 +191,7 @@ if result is not None:
     version = result.protocol_version
 ```
 
-The high-level `Client` exposes these directly as non-nullable properties (initialization is guaranteed inside the context manager): `client.server_capabilities`, `client.server_info`, and `client.server_instructions`.
+The high-level `Client.initialize_result` returns the same `InitializeResult` but is non-nullable — initialization is guaranteed inside the context manager, so no `None` check is needed. This replaces v1's `Client.server_capabilities`; use `client.initialize_result.capabilities` instead.
 
 ### `McpError` renamed to `MCPError`
 

src/mcp/client/client.py

@@ -30,7 +30,6 @@
     ReadResourceResult,
     RequestParamsMeta,
     ResourceTemplateReference,
-    ServerCapabilities,
 )
 
 
@@ -97,7 +96,6 @@ async def main():
     """Callback for handling elicitation requests."""
 
     _session: ClientSession | None = field(init=False, default=None)
-    _initialize_result: InitializeResult | None = field(init=False, default=None)
     _exit_stack: AsyncExitStack | None = field(init=False, default=None)
     _transport: Transport = field(init=False)
 
@@ -131,7 +129,7 @@ async def __aenter__(self) -> Client:
                 )
             )
 
-            self._initialize_result = await self._session.initialize()
+            await self._session.initialize()
 
             # Transfer ownership to self for __aexit__ to handle
             self._exit_stack = exit_stack.pop_all()
@@ -142,7 +140,6 @@ async def __aexit__(self, exc_type: type[BaseException] | None, exc_val: BaseExc
         if self._exit_stack:  # pragma: no branch
             await self._exit_stack.__aexit__(exc_type, exc_val, exc_tb)
         self._session = None
-        self._initialize_result = None
 
     @property
     def session(self) -> ClientSession:
@@ -158,25 +155,16 @@ def session(self) -> ClientSession:
         return self._session
 
     @property
-    def server_capabilities(self) -> ServerCapabilities:
-        """Capabilities the server advertised during initialization."""
-        if self._initialize_result is None:
-            raise RuntimeError("Client must be used within an async context manager")
-        return self._initialize_result.capabilities
-
-    @property
-    def server_info(self) -> Implementation:
-        """The server's name, version, and other implementation details."""
-        if self._initialize_result is None:
-            raise RuntimeError("Client must be used within an async context manager")
-        return self._initialize_result.server_info
+    def initialize_result(self) -> InitializeResult:
+        """The server's InitializeResult.
 
-    @property
-    def server_instructions(self) -> str | None:
-        """Instructions describing how to use the server and its features, if provided."""
-        if self._initialize_result is None:
+        Contains server_info, capabilities, instructions, and the negotiated protocol_version.
+        Raises RuntimeError if accessed outside the context manager.
+        """
+        result = self.session.initialize_result
+        if result is None:  # pragma: no cover
             raise RuntimeError("Client must be used within an async context manager")
-        return self._initialize_result.instructions
+        return result
 
     async def send_ping(self, *, meta: RequestParamsMeta | None = None) -> EmptyResult:
         """Send a ping request to the server."""

tests/client/test_client.py

@@ -99,16 +99,15 @@ def greeting_prompt(name: str) -> str:
 async def test_client_is_initialized(app: MCPServer):
     """Test that the client is initialized after entering context."""
     async with Client(app) as client:
-        assert client.server_capabilities == snapshot(
+        assert client.initialize_result.capabilities == snapshot(
             ServerCapabilities(
                 experimental={},
                 prompts=PromptsCapability(list_changed=False),
                 resources=ResourcesCapability(subscribe=False, list_changed=False),
                 tools=ToolsCapability(list_changed=False),
             )
         )
-        assert client.server_info.name == "test"
-        assert client.server_instructions is None
+        assert client.initialize_result.server_info.name == "test"
 
 
 async def test_client_with_simple_server(simple_server: Server):
@@ -196,17 +195,6 @@ def test_client_session_property_before_enter(app: MCPServer):
         client.session
 
 
-def test_client_server_properties_before_enter(app: MCPServer):
-    """Test that server_* properties raise RuntimeError outside the context manager."""
-    client = Client(app)
-    with pytest.raises(RuntimeError, match="Client must be used within an async context manager"):
-        client.server_capabilities
-    with pytest.raises(RuntimeError, match="Client must be used within an async context manager"):
-        client.server_info
-    with pytest.raises(RuntimeError, match="Client must be used within an async context manager"):
-        client.server_instructions
-
-
 async def test_client_reentry_raises_runtime_error(app: MCPServer):
     """Test that reentering a client raises RuntimeError."""
     async with Client(app) as client:

tests/client/transports/test_memory.py

@@ -69,7 +69,7 @@ async def test_with_mcpserver(mcpserver_server: MCPServer):
 async def test_server_is_running(mcpserver_server: MCPServer):
     """Test that the server is running and responding to requests."""
     async with Client(mcpserver_server) as client:
-        assert client.server_capabilities.tools is not None
+        assert client.initialize_result.capabilities.tools is not None
 
 
 async def test_list_tools(mcpserver_server: MCPServer):