@@ -201,3 +201,62 @@ async def test_invalid_json_response_sends_jsonrpc_error() -> None:
 
                 with pytest.raises(MCPError, match="Failed to parse JSON response"):  # pragma: no branch
                     await session.list_tools()
+
+
+def _create_non_2xx_json_body_app(status: int, body: bytes) -> Starlette:
+    """Server that returns a fixed non-2xx status + ``application/json`` body for non-init requests."""
+
+    async def handle_mcp_request(request: Request) -> Response:
+        data = json.loads(await request.body())
+        if data.get("method") == "initialize":
+            return _init_json_response(data)
+        if "id" not in data:
+            return Response(status_code=202)
+        return Response(content=body, status_code=status, media_type="application/json")
+
+    return Starlette(debug=True, routes=[Route("/mcp", handle_mcp_request, methods=["POST"])])
+
+
+async def test_client_surfaces_jsonrpc_error_from_non_2xx_body_with_correlated_id() -> None:
+    """SDK-defined: a JSON-RPC error in a non-2xx body is surfaced verbatim even when the
+    server set ``id: null`` — the client rewraps it under the pending request's id, so
+    the awaiting call resolves with the server's error code instead of the generic fallback."""
+    body = json.dumps(
+        {"jsonrpc": "2.0", "id": None, "error": {"code": types.METHOD_NOT_FOUND, "message": "nope"}}
+    ).encode()
+    app = _create_non_2xx_json_body_app(400, body)
+    async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app)) as client:
+        async with streamable_http_client("http://localhost/mcp", http_client=client) as (read_stream, write_stream):
+            async with ClientSession(read_stream, write_stream) as session:  # pragma: no branch
+                await session.initialize()
+                with pytest.raises(MCPError) as exc:
+                    await session.list_tools()
+                assert exc.value.error.code == types.METHOD_NOT_FOUND
+
+
+async def test_client_falls_back_to_generic_error_when_non_2xx_body_is_a_jsonrpc_result() -> None:
+    """SDK-defined: a non-2xx response whose JSON body parses as a JSON-RPC *result* (not an
+    error) falls through to the generic ``INTERNAL_ERROR`` fallback rather than being
+    treated as the request's reply."""
+    app = _create_non_2xx_json_body_app(400, b'{"jsonrpc":"2.0","id":1,"result":{}}')
+    async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app)) as client:
+        async with streamable_http_client("http://localhost/mcp", http_client=client) as (read_stream, write_stream):
+            async with ClientSession(read_stream, write_stream) as session:  # pragma: no branch
+                await session.initialize()
+                with pytest.raises(MCPError) as exc:
+                    await session.list_tools()
+                assert exc.value.error.code == types.INTERNAL_ERROR
+
+
+async def test_client_falls_back_to_session_terminated_when_404_body_is_malformed_json() -> None:
+    """SDK-defined: an unparseable ``application/json`` body on a 404 response is swallowed
+    and the status-derived ``INVALID_REQUEST`` (session-terminated) fallback resolves the
+    pending request — the parse failure never propagates."""
+    app = _create_non_2xx_json_body_app(404, b"not valid json{{{")
+    async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app)) as client:
+        async with streamable_http_client("http://localhost/mcp", http_client=client) as (read_stream, write_stream):
+            async with ClientSession(read_stream, write_stream) as session:  # pragma: no branch
+                await session.initialize()
+                with pytest.raises(MCPError) as exc:
+                    await session.list_tools()
+                assert exc.value.error.code == types.INVALID_REQUEST
@@ -356,6 +356,11 @@ def test_connection_check_capability_false_when_no_client_params_recorded():
             ClientCapabilities(sampling=SamplingCapability(tools=SamplingToolsCapability())),
             True,
         ),
+        (
+            ClientCapabilities(sampling=SamplingCapability(context=SamplingContextCapability())),
+            ClientCapabilities(sampling=SamplingCapability(context=SamplingContextCapability())),
+            True,
+        ),
         (ClientCapabilities(experimental=None), ClientCapabilities(experimental={"a": {}}), False),
         (ClientCapabilities(experimental={"a": {}}), ClientCapabilities(experimental={"b": {}}), False),
         (ClientCapabilities(experimental={"a": {"x": 1}}), ClientCapabilities(experimental={"a": {"x": 2}}), False),
 
@@ -795,6 +795,22 @@ async def short_circuit(ctx: Ctx, method: str, params: Any, call_next: Any) -> A
     assert exc.value.error == ErrorData(code=INVALID_PARAMS, message="denied")
 
 
+@pytest.mark.anyio
+async def test_runner_middleware_returning_non_model_surfaces_as_error(server: SrvT):
+    """SDK-defined: a middleware that short-circuits with a non-BaseModel/non-dict
+    value is rejected by ``_dump_result`` and surfaces as a JSON-RPC error rather
+    than leaking the raw return onto the wire."""
+
+    async def short_circuit(ctx: Ctx, method: str, params: Any, call_next: Any) -> Any:
+        return 42
+
+    server.middleware.append(short_circuit)
+    async with connected_runner(server, initialized=False) as (client, _):
+        with pytest.raises(MCPError) as exc:
+            await client.send_raw_request("tools/list", None)
+    assert "int" in exc.value.error.message
+
+
 @pytest.mark.anyio
 async def test_runner_handler_returning_unsupported_type_surfaces_as_error(server: SrvT):
     async def bad_return(ctx: Ctx, params: PaginatedRequestParams | None) -> int:
 
@@ -128,6 +128,17 @@ async def test_elicit_form_with_related_id_rides_the_request_channel():
     assert request_ch.requests[0][0] == "elicitation/create"
 
 
+@pytest.mark.anyio
+async def test_send_log_message_with_related_id_rides_the_request_channel():
+    """SDK-defined: the deprecated ``send_log_message`` notification with a related id
+    rides the per-request channel, so it is delivered even with no standalone back-channel."""
+    session, request_ch = _no_channel_session()
+    await session.send_log_message(  # pyright: ignore[reportDeprecated]
+        level="info", data="hello", logger="test", related_request_id=3
+    )
+    assert request_ch.notifications == [("notifications/message", {"level": "info", "data": "hello", "logger": "test"})]
+
+
 @pytest.mark.anyio
 async def test_unrelated_notification_is_dropped_silently():
     """SDK-defined: notifications on the no-channel standalone are best-effort — dropped, never raised."""
 
@@ -109,6 +109,30 @@ def _list_tools_body() -> dict[str, Any]:
     return {"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {"_meta": meta}}
 
 
+async def test_handle_modern_request_routes_with_mis_shaped_envelope_client_info() -> None:
+    """SDK-defined: a mis-shaped ``clientInfo`` envelope value is treated as not supplied —
+    the request still routes (200 + result) and the handler observes ``client_params is None``
+    rather than the request being rejected at the validation ladder. A non-spec method is
+    used so the kernel's per-method params validation does not re-reject the envelope."""
+    seen: list[object] = []
+
+    async def greet(ctx: ServerRequestContext, params: PaginatedRequestParams) -> dict[str, Any]:
+        seen.append(ctx.session._connection.client_params)
+        return {"ok": True}
+
+    server: Server[Any] = Server("test")
+    server.add_request_handler("custom/greet", PaginatedRequestParams, greet)
+
+    body = _list_tools_body()
+    body["method"] = "custom/greet"
+    body["params"]["_meta"][CLIENT_INFO_META_KEY] = "not-an-object"
+    async with _asgi_client(server) as http:
+        response = await http.post("/mcp", json=body, headers={"content-type": "application/json"})
+    assert response.status_code == 200
+    assert response.json()["result"] == {"ok": True}
+    assert seen == [None]
+
+
 async def test_handle_modern_request_sends_response_when_exit_stack_cleanup_raises(
     caplog: pytest.LogCaptureFixture,
 ) -> None: