From 44a770404ffea62b3ff62f4feaf0773d22a47eeb Mon Sep 17 00:00:00 2001
From: Max Isbey <224885523+maxisbey@users.noreply.github.com>
Date: Thu, 12 Mar 2026 17:45:42 +0000
Subject: [PATCH 1/4] feat(client): store full InitializeResult as
 server_params
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ClientSession now stores the complete InitializeResult via a server_params
property, mirroring ServerSession.client_params. This provides access to
server_info, capabilities, instructions, and the negotiated protocol_version
through a single, future-proof property.

Previously, only capabilities were stored (via _server_capabilities) and
users had no access to server_info, instructions, or protocol_version after
initialize() returned — they had to manually capture the return value.

get_server_capabilities() and Client.server_capabilities have been removed.

Github-Issue: #1018
---
 docs/migration.md                      | 24 +++++++++++++++++++++++
 src/mcp/client/client.py               | 11 +++++++----
 src/mcp/client/session.py              | 14 +++++++------
 tests/client/test_client.py            |  3 ++-
 tests/client/test_session.py           | 27 +++++++++++++-------------
 tests/client/transports/test_memory.py |  2 +-
 6 files changed, 55 insertions(+), 26 deletions(-)

diff --git a/docs/migration.md b/docs/migration.md
index 7cf032553..d10b48b12 100644
--- a/docs/migration.md
+++ b/docs/migration.md
@@ -169,6 +169,30 @@ result = await session.list_resources(params=PaginatedRequestParams(cursor="next
 result = await session.list_tools(params=PaginatedRequestParams(cursor="next_page_token"))
 ```
 
+### `ClientSession.get_server_capabilities()` replaced by `server_params` property
+
+`ClientSession` now stores the full `InitializeResult` via a `server_params` property, mirroring `ServerSession.client_params`. This is the new way to access server metadata after initialization — `server_info`, `capabilities`, `instructions`, and the negotiated `protocol_version` are all available through this single property. The `get_server_capabilities()` method has been removed.
+
+**Before (v1):**
+
+```python
+capabilities = session.get_server_capabilities()
+# server_info, instructions, protocol_version were not stored — had to capture initialize() return value
+```
+
+**After (v2):**
+
+```python
+params = session.server_params
+if params is not None:
+    capabilities = params.capabilities
+    server_info = params.server_info
+    instructions = params.instructions
+    version = params.protocol_version
+```
+
+The high-level `Client.server_capabilities` property has similarly been replaced by `Client.server_params`.
+
 ### `McpError` renamed to `MCPError`
 
 The `McpError` exception class has been renamed to `MCPError` for consistent naming with the MCP acronym style used throughout the SDK.
diff --git a/src/mcp/client/client.py b/src/mcp/client/client.py
index 7dc67c584..ab50ae80a 100644
--- a/src/mcp/client/client.py
+++ b/src/mcp/client/client.py
@@ -19,6 +19,7 @@
     EmptyResult,
     GetPromptResult,
     Implementation,
+    InitializeResult,
     ListPromptsResult,
     ListResourcesResult,
     ListResourceTemplatesResult,
@@ -29,7 +30,6 @@
     ReadResourceResult,
     RequestParamsMeta,
     ResourceTemplateReference,
-    ServerCapabilities,
 )
 
 
@@ -155,9 +155,12 @@ def session(self) -> ClientSession:
         return self._session
 
     @property
-    def server_capabilities(self) -> ServerCapabilities | None:
-        """The server capabilities received during initialization, or None if not yet initialized."""
-        return self.session.get_server_capabilities()
+    def server_params(self) -> InitializeResult | None:
+        """The server's initialization response. None if not yet initialized.
+
+        Contains server_info, capabilities, instructions, and the negotiated protocol_version.
+        """
+        return self.session.server_params
 
     async def send_ping(self, *, meta: RequestParamsMeta | None = None) -> EmptyResult:
         """Send a ping request to the server."""
diff --git a/src/mcp/client/session.py b/src/mcp/client/session.py
index a0ca751bd..2b3559358 100644
--- a/src/mcp/client/session.py
+++ b/src/mcp/client/session.py
@@ -131,7 +131,7 @@ def __init__(
         self._logging_callback = logging_callback or _default_logging_callback
         self._message_handler = message_handler or _default_message_handler
         self._tool_output_schemas: dict[str, dict[str, Any] | None] = {}
-        self._server_capabilities: types.ServerCapabilities | None = None
+        self._server_params: types.InitializeResult | None = None
         self._experimental_features: ExperimentalClientFeatures | None = None
 
         # Experimental: Task handlers (use defaults if not provided)
@@ -185,18 +185,20 @@ async def initialize(self) -> types.InitializeResult:
         if result.protocol_version not in SUPPORTED_PROTOCOL_VERSIONS:
             raise RuntimeError(f"Unsupported protocol version from the server: {result.protocol_version}")
 
-        self._server_capabilities = result.capabilities
+        self._server_params = result
 
         await self.send_notification(types.InitializedNotification())
 
         return result
 
-    def get_server_capabilities(self) -> types.ServerCapabilities | None:
-        """Return the server capabilities received during initialization.
+    @property
+    def server_params(self) -> types.InitializeResult | None:
+        """The server's initialization response. None if not yet initialized.
 
-        Returns None if the session has not been initialized yet.
+        Mirrors ServerSession.client_params. Contains server_info, capabilities,
+        instructions, and the negotiated protocol_version.
         """
-        return self._server_capabilities
+        return self._server_params
 
     @property
     def experimental(self) -> ExperimentalClientFeatures:
diff --git a/tests/client/test_client.py b/tests/client/test_client.py
index 3bdd30570..94a79e881 100644
--- a/tests/client/test_client.py
+++ b/tests/client/test_client.py
@@ -99,7 +99,8 @@ 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.server_params is not None
+        assert client.server_params.capabilities == snapshot(
             ServerCapabilities(
                 experimental={},
                 prompts=PromptsCapability(list_changed=False),
diff --git a/tests/client/test_session.py b/tests/client/test_session.py
index d6d13e273..76ac21269 100644
--- a/tests/client/test_session.py
+++ b/tests/client/test_session.py
@@ -540,8 +540,8 @@ async def mock_server():
 
 
 @pytest.mark.anyio
-async def test_get_server_capabilities():
-    """Test that get_server_capabilities returns None before init and capabilities after"""
+async def test_server_params():
+    """Test that server_params is None before init and contains the full result after."""
     client_to_server_send, client_to_server_receive = anyio.create_memory_object_stream[SessionMessage](1)
     server_to_client_send, server_to_client_receive = anyio.create_memory_object_stream[SessionMessage](1)
 
@@ -551,6 +551,8 @@ async def test_get_server_capabilities():
         resources=types.ResourcesCapability(subscribe=True, list_changed=True),
         tools=types.ToolsCapability(list_changed=False),
     )
+    expected_server_info = Implementation(name="mock-server", version="0.1.0")
+    expected_instructions = "Use the tools wisely."
 
     async def mock_server():
         session_message = await client_to_server_receive.receive()
@@ -564,7 +566,8 @@ async def mock_server():
         result = InitializeResult(
             protocol_version=LATEST_PROTOCOL_VERSION,
             capabilities=expected_capabilities,
-            server_info=Implementation(name="mock-server", version="0.1.0"),
+            server_info=expected_server_info,
+            instructions=expected_instructions,
         )
 
         async with server_to_client_send:
@@ -590,21 +593,17 @@ async def mock_server():
         server_to_client_send,
         server_to_client_receive,
     ):
-        assert session.get_server_capabilities() is None
+        assert session.server_params is None
 
         tg.start_soon(mock_server)
         await session.initialize()
 
-        capabilities = session.get_server_capabilities()
-        assert capabilities is not None
-        assert capabilities == expected_capabilities
-        assert capabilities.logging is not None
-        assert capabilities.prompts is not None
-        assert capabilities.prompts.list_changed is True
-        assert capabilities.resources is not None
-        assert capabilities.resources.subscribe is True
-        assert capabilities.tools is not None
-        assert capabilities.tools.list_changed is False
+        params = session.server_params
+        assert params is not None
+        assert params.server_info == expected_server_info
+        assert params.capabilities == expected_capabilities
+        assert params.instructions == expected_instructions
+        assert params.protocol_version == LATEST_PROTOCOL_VERSION
 
 
 @pytest.mark.anyio
diff --git a/tests/client/transports/test_memory.py b/tests/client/transports/test_memory.py
index 47be3e208..4d9944bdb 100644
--- a/tests/client/transports/test_memory.py
+++ b/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 is not None
+        assert client.server_params is not None
 
 
 async def test_list_tools(mcpserver_server: MCPServer):

From ec5fe677f3706dc2128719b0518032017ceeee7f Mon Sep 17 00:00:00 2001
From: Max Isbey <224885523+maxisbey@users.noreply.github.com>
Date: Tue, 17 Mar 2026 19:58:06 +0000
Subject: [PATCH 2/4] refactor(client): rename to initialize_result, decompose
 Client properties

- ClientSession.server_params -> initialize_result (avoids collision with
  StdioServerParameters idiom; matches Go SDK and FastMCP)
- Client: replace server_params proxy with non-nullable server_capabilities,
  server_info, server_instructions (init is guaranteed inside the context
  manager, so | None was unreachable)
- Client.server_capabilities is preserved from v1 with a better type

Github-Issue: #1018
---
 docs/migration.md                      | 18 ++++++++---------
 src/mcp/client/client.py               | 28 ++++++++++++++++++++------
 src/mcp/client/session.py              | 13 ++++++------
 tests/client/test_client.py            | 16 +++++++++++++--
 tests/client/test_session.py           | 18 ++++++++---------
 tests/client/transports/test_memory.py |  2 +-
 6 files changed, 61 insertions(+), 34 deletions(-)

diff --git a/docs/migration.md b/docs/migration.md
index d10b48b12..13110a5f1 100644
--- a/docs/migration.md
+++ b/docs/migration.md
@@ -169,9 +169,9 @@ result = await session.list_resources(params=PaginatedRequestParams(cursor="next
 result = await session.list_tools(params=PaginatedRequestParams(cursor="next_page_token"))
 ```
 
-### `ClientSession.get_server_capabilities()` replaced by `server_params` property
+### `ClientSession.get_server_capabilities()` replaced by `initialize_result` property
 
-`ClientSession` now stores the full `InitializeResult` via a `server_params` property, mirroring `ServerSession.client_params`. This is the new way to access server metadata after initialization — `server_info`, `capabilities`, `instructions`, and the negotiated `protocol_version` are all available through this single property. The `get_server_capabilities()` method has been removed.
+`ClientSession` now stores the full `InitializeResult` via an `initialize_result` property. This provides access to `server_info`, `capabilities`, `instructions`, and the negotiated `protocol_version` through a single property. The `get_server_capabilities()` method has been removed.
 
 **Before (v1):**
 
@@ -183,15 +183,15 @@ capabilities = session.get_server_capabilities()
 **After (v2):**
 
 ```python
-params = session.server_params
-if params is not None:
-    capabilities = params.capabilities
-    server_info = params.server_info
-    instructions = params.instructions
-    version = params.protocol_version
+result = session.initialize_result
+if result is not None:
+    capabilities = result.capabilities
+    server_info = result.server_info
+    instructions = result.instructions
+    version = result.protocol_version
 ```
 
-The high-level `Client.server_capabilities` property has similarly been replaced by `Client.server_params`.
+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`.
 
 ### `McpError` renamed to `MCPError`
 
diff --git a/src/mcp/client/client.py b/src/mcp/client/client.py
index ab50ae80a..5c131380c 100644
--- a/src/mcp/client/client.py
+++ b/src/mcp/client/client.py
@@ -30,6 +30,7 @@
     ReadResourceResult,
     RequestParamsMeta,
     ResourceTemplateReference,
+    ServerCapabilities,
 )
 
 
@@ -96,6 +97,7 @@ 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)
 
@@ -129,7 +131,7 @@ async def __aenter__(self) -> Client:
                 )
             )
 
-            await self._session.initialize()
+            self._initialize_result = await self._session.initialize()
 
             # Transfer ownership to self for __aexit__ to handle
             self._exit_stack = exit_stack.pop_all()
@@ -140,6 +142,7 @@ 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:
@@ -155,12 +158,25 @@ def session(self) -> ClientSession:
         return self._session
 
     @property
-    def server_params(self) -> InitializeResult | None:
-        """The server's initialization response. None if not yet initialized.
+    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
 
-        Contains server_info, capabilities, instructions, and the negotiated protocol_version.
-        """
-        return self.session.server_params
+    @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
+
+    @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:
+            raise RuntimeError("Client must be used within an async context manager")
+        return self._initialize_result.instructions
 
     async def send_ping(self, *, meta: RequestParamsMeta | None = None) -> EmptyResult:
         """Send a ping request to the server."""
diff --git a/src/mcp/client/session.py b/src/mcp/client/session.py
index 2b3559358..7c964a334 100644
--- a/src/mcp/client/session.py
+++ b/src/mcp/client/session.py
@@ -131,7 +131,7 @@ def __init__(
         self._logging_callback = logging_callback or _default_logging_callback
         self._message_handler = message_handler or _default_message_handler
         self._tool_output_schemas: dict[str, dict[str, Any] | None] = {}
-        self._server_params: types.InitializeResult | None = None
+        self._initialize_result: types.InitializeResult | None = None
         self._experimental_features: ExperimentalClientFeatures | None = None
 
         # Experimental: Task handlers (use defaults if not provided)
@@ -185,20 +185,19 @@ async def initialize(self) -> types.InitializeResult:
         if result.protocol_version not in SUPPORTED_PROTOCOL_VERSIONS:
             raise RuntimeError(f"Unsupported protocol version from the server: {result.protocol_version}")
 
-        self._server_params = result
+        self._initialize_result = result
 
         await self.send_notification(types.InitializedNotification())
 
         return result
 
     @property
-    def server_params(self) -> types.InitializeResult | None:
-        """The server's initialization response. None if not yet initialized.
+    def initialize_result(self) -> types.InitializeResult | None:
+        """The server's InitializeResult. None until initialize() has been called.
 
-        Mirrors ServerSession.client_params. Contains server_info, capabilities,
-        instructions, and the negotiated protocol_version.
+        Contains server_info, capabilities, instructions, and the negotiated protocol_version.
         """
-        return self._server_params
+        return self._initialize_result
 
     @property
     def experimental(self) -> ExperimentalClientFeatures:
diff --git a/tests/client/test_client.py b/tests/client/test_client.py
index 94a79e881..47312e435 100644
--- a/tests/client/test_client.py
+++ b/tests/client/test_client.py
@@ -99,8 +99,7 @@ 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_params is not None
-        assert client.server_params.capabilities == snapshot(
+        assert client.server_capabilities == snapshot(
             ServerCapabilities(
                 experimental={},
                 prompts=PromptsCapability(list_changed=False),
@@ -108,6 +107,8 @@ async def test_client_is_initialized(app: MCPServer):
                 tools=ToolsCapability(list_changed=False),
             )
         )
+        assert client.server_info.name == "test"
+        assert client.server_instructions is None
 
 
 async def test_client_with_simple_server(simple_server: Server):
@@ -210,6 +211,17 @@ 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:
diff --git a/tests/client/test_session.py b/tests/client/test_session.py
index 76ac21269..f25c964f0 100644
--- a/tests/client/test_session.py
+++ b/tests/client/test_session.py
@@ -540,8 +540,8 @@ async def mock_server():
 
 
 @pytest.mark.anyio
-async def test_server_params():
-    """Test that server_params is None before init and contains the full result after."""
+async def test_initialize_result():
+    """Test that initialize_result is None before init and contains the full result after."""
     client_to_server_send, client_to_server_receive = anyio.create_memory_object_stream[SessionMessage](1)
     server_to_client_send, server_to_client_receive = anyio.create_memory_object_stream[SessionMessage](1)
 
@@ -593,17 +593,17 @@ async def mock_server():
         server_to_client_send,
         server_to_client_receive,
     ):
-        assert session.server_params is None
+        assert session.initialize_result is None
 
         tg.start_soon(mock_server)
         await session.initialize()
 
-        params = session.server_params
-        assert params is not None
-        assert params.server_info == expected_server_info
-        assert params.capabilities == expected_capabilities
-        assert params.instructions == expected_instructions
-        assert params.protocol_version == LATEST_PROTOCOL_VERSION
+        result = session.initialize_result
+        assert result is not None
+        assert result.server_info == expected_server_info
+        assert result.capabilities == expected_capabilities
+        assert result.instructions == expected_instructions
+        assert result.protocol_version == LATEST_PROTOCOL_VERSION
 
 
 @pytest.mark.anyio
diff --git a/tests/client/transports/test_memory.py b/tests/client/transports/test_memory.py
index 4d9944bdb..bf3e3c184 100644
--- a/tests/client/transports/test_memory.py
+++ b/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_params is not None
+        assert client.server_capabilities.tools is not None
 
 
 async def test_list_tools(mcpserver_server: MCPServer):

From 668d172e894fae6bceb4c4fce59dff438005bbe4 Mon Sep 17 00:00:00 2001
From: Max Isbey <224885523+maxisbey@users.noreply.github.com>
Date: Wed, 18 Mar 2026 13:18:30 +0000
Subject: [PATCH 3/4] 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
---
 docs/migration.md                      |  2 +-
 src/mcp/client/client.py               | 30 ++++++++------------------
 tests/client/test_client.py            | 16 ++------------
 tests/client/transports/test_memory.py |  2 +-
 4 files changed, 13 insertions(+), 37 deletions(-)

diff --git a/docs/migration.md b/docs/migration.md
index 13110a5f1..dd6a7a18f 100644
--- a/docs/migration.md
+++ b/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`
 
diff --git a/src/mcp/client/client.py b/src/mcp/client/client.py
index 5c131380c..34d6a360f 100644
--- a/src/mcp/client/client.py
+++ b/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."""
diff --git a/tests/client/test_client.py b/tests/client/test_client.py
index 47312e435..18368e6bb 100644
--- a/tests/client/test_client.py
+++ b/tests/client/test_client.py
@@ -99,7 +99,7 @@ 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),
@@ -107,8 +107,7 @@ async def test_client_is_initialized(app: MCPServer):
                 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):
@@ -211,17 +210,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:
diff --git a/tests/client/transports/test_memory.py b/tests/client/transports/test_memory.py
index bf3e3c184..c8fc41fd5 100644
--- a/tests/client/transports/test_memory.py
+++ b/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):

From 24217ae891e9b64ce697881f553d79c5b1d3a520 Mon Sep 17 00:00:00 2001
From: Max Isbey <224885523+maxisbey@users.noreply.github.com>
Date: Wed, 18 Mar 2026 16:18:19 +0000
Subject: [PATCH 4/4] fix(tests): update test_integration.py for
 initialize_result

Main added 11 client.server_capabilities callsites while this branch
was in flight. Each was a 2-line narrowing-check-then-real-check pair;
collapses to 1 line since initialize_result is non-nullable.

Github-Issue: #1018
---
 tests/server/mcpserver/test_integration.py | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/tests/server/mcpserver/test_integration.py b/tests/server/mcpserver/test_integration.py
index 90e333b77..f71c0574c 100644
--- a/tests/server/mcpserver/test_integration.py
+++ b/tests/server/mcpserver/test_integration.py
@@ -109,8 +109,7 @@ async def elicitation_callback(context: RequestContext[ClientSession], params: E
 async def test_basic_tools() -> None:
     """Test basic tool functionality."""
     async with Client(basic_tool.mcp) as client:
-        assert client.server_capabilities is not None
-        assert client.server_capabilities.tools is not None
+        assert client.initialize_result.capabilities.tools is not None
 
         # Test sum tool
         tool_result = await client.call_tool("sum", {"a": 5, "b": 3})
@@ -128,8 +127,7 @@ async def test_basic_tools() -> None:
 async def test_basic_resources() -> None:
     """Test basic resource functionality."""
     async with Client(basic_resource.mcp) as client:
-        assert client.server_capabilities is not None
-        assert client.server_capabilities.resources is not None
+        assert client.initialize_result.capabilities.resources is not None
 
         # Test document resource
         doc_content = await client.read_resource("file://documents/readme")
@@ -151,8 +149,7 @@ async def test_basic_resources() -> None:
 async def test_basic_prompts() -> None:
     """Test basic prompt functionality."""
     async with Client(basic_prompt.mcp) as client:
-        assert client.server_capabilities is not None
-        assert client.server_capabilities.prompts is not None
+        assert client.initialize_result.capabilities.prompts is not None
 
         # Test review_code prompt
         prompts = await client.list_prompts()
@@ -223,8 +220,7 @@ async def progress_callback(progress: float, total: float | None, message: str |
 async def test_sampling() -> None:
     """Test sampling (LLM interaction) functionality."""
     async with Client(sampling.mcp, sampling_callback=sampling_callback) as client:
-        assert client.server_capabilities is not None
-        assert client.server_capabilities.tools is not None
+        assert client.initialize_result.capabilities.tools is not None
 
         # Test sampling tool
         sampling_result = await client.call_tool("generate_poem", {"topic": "nature"})
@@ -294,9 +290,8 @@ async def message_handler(message: RequestResponder[ServerRequest, ClientResult]
 async def test_completion() -> None:
     """Test completion (autocomplete) functionality."""
     async with Client(completion.mcp) as client:
-        assert client.server_capabilities is not None
-        assert client.server_capabilities.resources is not None
-        assert client.server_capabilities.prompts is not None
+        assert client.initialize_result.capabilities.resources is not None
+        assert client.initialize_result.capabilities.prompts is not None
 
         # Test resource completion
         completion_result = await client.complete(