test: build the in-memory MCP session from the pieces the SDK promises

`test_agent_to_mcp` reaches the agent server through
`mcp.shared.memory.create_connected_server_and_client_session`. That helper is a
convenience wrapper the SDK does not promise, and this file is the only place in
ADK that uses it.

Assemble the session here instead, from the four pieces underneath it that the
SDK does promise: `create_client_server_memory_streams`, the low-level server's
`run`, its `create_initialization_options`, and `ClientSession`. Same wiring, so
no test changes behaviour.

`raise_exceptions` now defaults to True. The wrapper defaulted to False, which
turns a raising handler into an error result and hides the traceback. No test
here relied on that.

Reaching the low-level server behind the high-level one is the one step with no
public route. `_lowlevel_server` does it, and tries both names the SDK has given
that attribute, so the helper does not pin a private name to one spelling.

Co-authored-by: Kathy Wu <wukathy@google.com>
PiperOrigin-RevId: 970124629

Author: wukath

tests/unittests/tools/mcp_tool/_in_memory_session.py

@@ -0,0 +1,89 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""An in-memory client session for testing `to_mcp_server`.
+
+`mcp.shared.memory.create_connected_server_and_client_session` does the same
+thing, but it is a convenience wrapper the SDK does not promise. This builds the
+session from the four pieces underneath it, each of which the SDK does promise:
+the memory stream pair, the low-level server's `run`, its initialization
+options, and `ClientSession`.
+"""
+
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+from typing import Any
+from typing import AsyncGenerator
+
+import anyio
+from mcp.client.session import ClientSession
+from mcp.shared.memory import create_client_server_memory_streams
+
+
+def _lowlevel_server(server: Any) -> Any:
+  """Returns the low-level server that `server` wraps, or `server` itself."""
+  # The high-level server holds the low-level one privately and offers no
+  # accessor. The SDK's own in-memory helper reaches for it the same way.
+  for name in ("_mcp_server", "_lowlevel_server"):
+    wrapped = getattr(server, name, None)
+    if wrapped is not None:
+      return wrapped
+  return server
+
+
+@asynccontextmanager
+async def connected_client_session(
+    server: Any,
+    *,
+    raise_exceptions: bool = True,
+) -> AsyncGenerator[ClientSession, None]:
+  """Yields an initialized `ClientSession` talking to `server` in memory.
+
+  Args:
+    server: The server to connect to, high-level or low-level.
+    raise_exceptions: Whether a handler that raises should take the server down
+      rather than return the error to the client. On by default, so a test sees
+      the traceback instead of an error result.
+
+  Yields:
+    A `ClientSession` that has completed the initialize handshake.
+  """
+  server = _lowlevel_server(server)
+
+  async with create_client_server_memory_streams() as (
+      client_streams,
+      server_streams,
+  ):
+    client_read, client_write = client_streams
+    server_read, server_write = server_streams
+
+    async with anyio.create_task_group() as task_group:
+      task_group.start_soon(
+          lambda: server.run(
+              server_read,
+              server_write,
+              server.create_initialization_options(),
+              raise_exceptions=raise_exceptions,
+          )
+      )
+      try:
+        async with ClientSession(
+            read_stream=client_read,
+            write_stream=client_write,
+        ) as session:
+          await session.initialize()
+          yield session
+      finally:
+        task_group.cancel_scope.cancel()

tests/unittests/tools/mcp_tool/test_agent_to_mcp.py

@@ -25,9 +25,10 @@
 from google.adk.tools.mcp_tool._agent_to_mcp import _run_agent
 from google.adk.tools.mcp_tool._agent_to_mcp import to_mcp_server
 from google.genai import types
-from mcp.shared.memory import create_connected_server_and_client_session
 import pytest
 
+from ._in_memory_session import connected_client_session
+
 
 class _EchoAgent(BaseAgent):
   """Minimal agent that emits a single final text event."""
@@ -153,7 +154,7 @@ async def test_call_tool_runs_agent_end_to_end():
   agent = _EchoAgent(name="assistant")
   server = to_mcp_server(agent)
 
-  async with create_connected_server_and_client_session(server) as client:
+  async with connected_client_session(server) as client:
     result = await client.call_tool("assistant", {"request": "hi"})
 
   assert not result.isError
@@ -275,7 +276,7 @@ async def test_call_tool_reuses_session_across_calls_on_one_connection():
   runner = _FakeRunner([_text_event("ok")])
   server = to_mcp_server(agent, runner=runner)
 
-  async with create_connected_server_and_client_session(server) as client:
+  async with connected_client_session(server) as client:
     await client.call_tool("assistant", {"request": "first"})
     await client.call_tool("assistant", {"request": "second"})