test: add lifecycle edge cases, concurrency, and behaviour-gap interaction tests

Adds ClientSession-level tests for pre-initialization request rejection and
protocol version negotiation, a proof that concurrent tool calls are
dispatched simultaneously and answered independently, and tests pinning
three behaviour gaps: tool-set mutations send no list_changed notification,
logging/setLevel is not supported by MCPServer and no level filtering
exists, and tool-enabled sampling is rejected because the high-level client
cannot declare the sampling.tools capability.

Author: maxisbey

tests/interaction/_requirements.py

@@ -95,6 +95,17 @@ class Requirement:
             "(sampling, elicitation, roots)."
         ),
     ),
+    "lifecycle:initialize:protocol-version": Requirement(
+        source=f"{SPEC_BASE_URL}/basic/lifecycle#version-negotiation",
+        behavior=(
+            "The server echoes a requested protocol version it supports, and answers an unsupported "
+            "requested version with its own latest supported version rather than an error."
+        ),
+    ),
+    "lifecycle:requests-before-initialized": Requirement(
+        source=f"{SPEC_BASE_URL}/basic/lifecycle#initialization",
+        behavior="A request sent before the initialization handshake completes is rejected with an error.",
+    ),
     # ═══════════════════════════════════════════════════════════════════════════
     # Cancellation
     # ═══════════════════════════════════════════════════════════════════════════
@@ -279,6 +290,13 @@ class Requirement:
         source=f"{SPEC_BASE_URL}/server/tools#error-handling",
         behavior="tools/call for a name the server does not recognise returns a JSON-RPC error.",
     ),
+    "tools:call:concurrent": Requirement(
+        source=f"{SPEC_BASE_URL}/basic#requests",
+        behavior=(
+            "Multiple tool calls in flight on one session are dispatched concurrently, and each caller "
+            "receives the response to its own request."
+        ),
+    ),
     "tools:call:invalid-arguments": Requirement(
         source=f"{SPEC_BASE_URL}/server/tools#error-handling",
         behavior=(
@@ -326,6 +344,21 @@ class Requirement:
         source=f"{SPEC_BASE_URL}/server/utilities/logging#log-levels",
         behavior="All eight RFC 5424 severity levels are deliverable as log message notifications.",
     ),
+    "logging:set-level:filtering": Requirement(
+        source=f"{SPEC_BASE_URL}/server/utilities/logging#log-levels",
+        behavior=(
+            "MCPServer registers no logging/setLevel handler (the request is rejected with method-not-found) "
+            "and log messages are delivered at every severity regardless of any requested level."
+        ),
+        divergence=Divergence(
+            note=(
+                "The spec says servers SHOULD only send log messages at or above the level the client "
+                "configured via logging/setLevel. Neither MCPServer (which rejects the request outright) "
+                "nor the low-level Server (which leaves the handler entirely to the author) implements "
+                "any filtering."
+            ),
+        ),
+    ),
     # ═══════════════════════════════════════════════════════════════════════════
     # Resources
     # ═══════════════════════════════════════════════════════════════════════════
@@ -426,6 +459,25 @@ class Requirement:
         source=f"{SPEC_BASE_URL}/client/sampling#message-content",
         behavior="Sampling messages can carry image content: base64 data with a mimeType.",
     ),
+    "sampling:create-message:tools:not-supported": Requirement(
+        source=f"{SPEC_BASE_URL}/client/sampling#capabilities",
+        behavior=(
+            "A tool-enabled sampling request to a client that did not declare sampling.tools is rejected "
+            "by the server before anything reaches the wire, with an Invalid params error."
+        ),
+    ),
+    "sampling:create-message:tools:round-trip": Requirement(
+        source=f"{SPEC_BASE_URL}/client/sampling#sampling-with-tools",
+        behavior=(
+            "A sampling request carrying tools and toolChoice reaches the client, and a tool_use response "
+            "with a toolUse stop reason returns to the requesting handler."
+        ),
+        deferred=(
+            "Not expressible through the public API: Client does not expose ClientSession's "
+            "sampling_capabilities parameter, so a client can never declare sampling.tools and the "
+            "server-side validator rejects every tool-enabled request before it is sent."
+        ),
+    ),
     "sampling:create-message:client-error": Requirement(
         source=f"{SPEC_BASE_URL}/client/sampling#error-handling",
         behavior="A sampling callback that returns an error is surfaced to the requesting handler as an MCPError.",
@@ -599,6 +651,19 @@ class Requirement:
         source="sdk",
         behavior="Context.read_resource reads a resource registered on the same server from inside a tool.",
     ),
+    "mcpserver:tools:list-changed-on-mutation": Requirement(
+        source="sdk",
+        behavior=(
+            "Adding or removing a tool on a running server changes what tools/list returns but sends no "
+            "notification to connected clients."
+        ),
+        divergence=Divergence(
+            note=(
+                "The spec provides notifications/tools/list_changed for exactly this case; MCPServer never "
+                "sends it, so a connected client cannot learn that the tool set changed without polling."
+            ),
+        ),
+    ),
     "mcpserver:tools:handler-exception": Requirement(
         source="sdk",
         behavior=(

tests/interaction/lowlevel/test_initialize.py

@@ -1,17 +1,33 @@
-"""Initialization handshake against the low-level Server, driven through the public Client API."""
+"""Initialization handshake against the low-level Server, driven through the public Client API.
 
+The last two tests drive a bare ClientSession over an InMemoryTransport instead: Client always
+performs the full handshake with the latest protocol version, so skipping initialization or
+requesting a different version can only be expressed one level down.
+"""
+
+import anyio
 import pytest
 from inline_snapshot import snapshot
 
-from mcp import types
-from mcp.client import ClientRequestContext
+from mcp import MCPError, types
+from mcp.client import ClientRequestContext, ClientSession
+from mcp.client._memory import InMemoryTransport
 from mcp.client.client import Client
 from mcp.server import Server, ServerRequestContext
 from mcp.types import (
+    INVALID_PARAMS,
     CallToolResult,
+    ClientCapabilities,
     CompletionsCapability,
+    EmptyResult,
+    ErrorData,
     Icon,
     Implementation,
+    InitializeRequest,
+    InitializeRequestParams,
+    InitializeResult,
+    ListToolsRequest,
+    ListToolsResult,
     LoggingCapability,
     PromptsCapability,
     ResourcesCapability,
@@ -198,3 +214,64 @@ async def list_roots(context: ClientRequestContext) -> types.ListRootsResult:
     async with Client(server, list_roots_callback=list_roots) as client:
         result = await client.call_tool("abilities", {})
     assert result == snapshot(CallToolResult(content=[TextContent(text="roots")]))
+
+
+@requirement("lifecycle:requests-before-initialized")
+async def test_request_before_initialization_is_rejected() -> None:
+    """A feature request sent before the handshake completes is rejected; ping is exempt.
+
+    Client always initializes on entry, so this drives a bare ClientSession that never sends
+    initialize. The server's stated reason for the rejection never reaches the client: the error
+    is reported as a generic invalid-params failure.
+    """
+
+    async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult:
+        """Registered so the request is routed to a real handler; never reached."""
+        raise NotImplementedError
+
+    server = Server("strict", on_list_tools=list_tools)
+
+    async with InMemoryTransport(server) as (read_stream, write_stream):
+        async with ClientSession(read_stream, write_stream) as session:
+            with anyio.fail_after(5):
+                with pytest.raises(MCPError) as exc_info:
+                    await session.send_request(ListToolsRequest(), ListToolsResult)
+
+                # Ping is explicitly permitted before initialization completes.
+                pong = await session.send_ping()
+
+    assert exc_info.value.error == snapshot(
+        ErrorData(code=INVALID_PARAMS, message="Invalid request parameters", data="")
+    )
+    assert pong == snapshot(EmptyResult())
+
+
+@requirement("lifecycle:initialize:protocol-version")
+async def test_initialize_negotiates_protocol_version() -> None:
+    """The server echoes a supported requested version and answers an unsupported one with its latest.
+
+    Client always requests the latest version, so each half hand-builds an InitializeRequest on a
+    bare ClientSession to control the requested version.
+    """
+    server = Server("negotiator")
+
+    def initialize_request(protocol_version: str) -> InitializeRequest:
+        return InitializeRequest(
+            params=InitializeRequestParams(
+                protocol_version=protocol_version,
+                capabilities=ClientCapabilities(),
+                client_info=Implementation(name="time-traveller", version="0.0.1"),
+            )
+        )
+
+    async with InMemoryTransport(server) as (read_stream, write_stream):
+        async with ClientSession(read_stream, write_stream) as session:
+            with anyio.fail_after(5):
+                result = await session.send_request(initialize_request("2025-03-26"), InitializeResult)
+    assert result.protocol_version == snapshot("2025-03-26")
+
+    async with InMemoryTransport(server) as (read_stream, write_stream):
+        async with ClientSession(read_stream, write_stream) as session:
+            with anyio.fail_after(5):
+                result = await session.send_request(initialize_request("1999-01-01"), InitializeResult)
+    assert result.protocol_version == snapshot("2025-11-25")

tests/interaction/lowlevel/test_sampling.py

@@ -289,3 +289,44 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara
         result = await client.call_tool("ask_model", {})
 
     assert result == snapshot(CallToolResult(content=[TextContent(text="-32600: Sampling not supported")]))
+
+
+@requirement("sampling:create-message:tools:not-supported")
+async def test_create_message_with_tools_is_rejected_for_unsupporting_client() -> None:
+    """A tool-enabled sampling request to a client that has not declared sampling.tools never leaves the server.
+
+    The client supports plain sampling but cannot declare the tools sub-capability (Client does not
+    expose it), so the server-side validator rejects the request before anything reaches the wire.
+    """
+
+    async def list_tools(
+        ctx: ServerRequestContext, params: types.PaginatedRequestParams | None
+    ) -> types.ListToolsResult:
+        return types.ListToolsResult(tools=[types.Tool(name="ask_model", input_schema={"type": "object"})])
+
+    async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult:
+        assert params.name == "ask_model"
+        try:
+            await ctx.session.create_message(
+                messages=[SamplingMessage(role="user", content=TextContent(text="What is the weather?"))],
+                max_tokens=100,
+                tools=[types.Tool(name="get_weather", input_schema={"type": "object"})],
+            )
+        except MCPError as exc:
+            return CallToolResult(content=[TextContent(text=f"{exc.error.code}: {exc.error.message}")])
+        raise NotImplementedError  # the validator rejects every tool-enabled request
+
+    server = Server("sampler", on_list_tools=list_tools, on_call_tool=call_tool)
+
+    async def sampling_callback(
+        context: ClientRequestContext, params: CreateMessageRequestParams
+    ) -> CreateMessageResult:
+        """Declares the plain sampling capability; never invoked because the request is rejected first."""
+        raise NotImplementedError
+
+    async with Client(server, sampling_callback=sampling_callback) as client:
+        result = await client.call_tool("ask_model", {})
+
+    assert result == snapshot(
+        CallToolResult(content=[TextContent(text="-32602: Client does not support sampling tools capability")])
+    )

tests/interaction/lowlevel/test_tools.py

@@ -1,5 +1,6 @@
 """Tool interactions against the low-level Server, driven through the public Client API."""
 
+import anyio
 import pytest
 from inline_snapshot import snapshot
 
@@ -264,3 +265,55 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara
         result = await client.call_tool("sum", {})
 
     assert result == snapshot(CallToolResult(content=[TextContent(text="the sum is 5")], structured_content={"sum": 5}))
+
+
+@requirement("tools:call:concurrent")
+async def test_concurrent_tool_calls_complete_independently() -> None:
+    """Two tool calls in flight at once run concurrently and each caller gets its own answer.
+
+    Both handlers are held on a shared event after signalling that they have started, and the test
+    only releases them once both signals have arrived -- a server that processed requests
+    sequentially would never start the second handler and the test would time out instead.
+    """
+    started: list[str] = []
+    started_events = {"first": anyio.Event(), "second": anyio.Event()}
+    release = anyio.Event()
+    results: dict[str, CallToolResult] = {}
+
+    async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestParams | None) -> ListToolsResult:
+        return ListToolsResult(tools=[Tool(name="echo", input_schema={"type": "object"})])
+
+    async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> CallToolResult:
+        assert params.name == "echo"
+        assert params.arguments is not None
+        tag = params.arguments["tag"]
+        assert isinstance(tag, str)
+        started.append(tag)
+        started_events[tag].set()
+        await release.wait()
+        return CallToolResult(content=[TextContent(text=tag)])
+
+    server = Server("echoer", on_list_tools=list_tools, on_call_tool=call_tool)
+
+    async with Client(server) as client:
+        with anyio.fail_after(5):
+            async with anyio.create_task_group() as task_group:
+
+                async def call_and_record(tag: str) -> None:
+                    results[tag] = await client.call_tool("echo", {"tag": tag})
+
+                task_group.start_soon(call_and_record, "first")
+                task_group.start_soon(call_and_record, "second")
+
+                # Both handlers are running at the same time before either is allowed to finish.
+                await started_events["first"].wait()
+                await started_events["second"].wait()
+                release.set()
+
+    assert sorted(started) == ["first", "second"]
+    assert results == snapshot(
+        {
+            "first": CallToolResult(content=[TextContent(text="first")]),
+            "second": CallToolResult(content=[TextContent(text="second")]),
+        }
+    )

tests/interaction/mcpserver/test_context.py

@@ -4,15 +4,18 @@
 from inline_snapshot import snapshot
 from pydantic import BaseModel
 
+from mcp import MCPError
 from mcp.client import ClientRequestContext
 from mcp.client.client import Client
 from mcp.server.elicitation import AcceptedElicitation
 from mcp.server.mcpserver import Context, MCPServer
 from mcp.types import (
+    METHOD_NOT_FOUND,
     CallToolResult,
     ElicitRequestFormParams,
     ElicitRequestParams,
     ElicitResult,
+    ErrorData,
     LoggingMessageNotificationParams,
     TextContent,
 )
@@ -163,3 +166,39 @@ async def show_config(ctx: Context) -> str:
             structured_content={"result": "text/plain: 'theme = dark'"},
         )
     )
+
+
+@requirement("logging:set-level:filtering")
+async def test_set_logging_level_is_rejected_and_messages_are_never_filtered() -> None:
+    """MCPServer does not support logging/setLevel, so log messages are never filtered by severity.
+
+    The request is rejected with METHOD_NOT_FOUND because MCPServer registers no handler for it,
+    and every message a tool emits is delivered regardless of level. The spec says the server
+    should only send messages at or above the configured level; with no way to configure one,
+    everything is sent.
+    """
+    received: list[LoggingMessageNotificationParams] = []
+    mcp = MCPServer("unfilterable")
+
+    @mcp.tool()
+    async def chatter(ctx: Context) -> str:
+        await ctx.debug("noise")
+        await ctx.error("signal")
+        return "done"
+
+    async def collect(params: LoggingMessageNotificationParams) -> None:
+        received.append(params)
+
+    async with Client(mcp, logging_callback=collect) as client:
+        with pytest.raises(MCPError) as exc_info:
+            await client.set_logging_level("error")
+
+        await client.call_tool("chatter", {})
+
+    assert exc_info.value.error == snapshot(ErrorData(code=METHOD_NOT_FOUND, message="Method not found"))
+    assert received == snapshot(
+        [
+            LoggingMessageNotificationParams(level="debug", data="noise"),
+            LoggingMessageNotificationParams(level="error", data="signal"),
+        ]
+    )