chore(deps): update dependency mcp to v2 (#1329)

* chore(deps): update dependency mcp to v2

* test(e2e): use mcp v2 streamable_http_client

mcp 2.0 removed streamablehttp_client; its replacement takes an httpx
client instead of headers and yields (read, write) without the session-id
callback.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(e2e): use mcp v2 snake_case field names

mcp 2.0 types expose snake_case attributes (is_error, input_schema,
mime_type, read_only_hint, ...); camelCase stays valid only as an input
alias.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: renovate-sh-app[bot] <219655108+renovate-sh-app[bot]@users.noreply.github.com>
Co-authored-by: Ben Sully <ben.sully@grafana.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: 3 people

tests/alerting_test.py

@@ -381,7 +381,7 @@ async def alert_rule_for_tests(mcp_client: ClientSession):
             "labels": {"team": "python-e2e"},
         },
     )
-    assert not result.isError, f"Failed to create test rule: {result.content}"
+    assert not result.is_error, f"Failed to create test rule: {result.content}"
 
     yield rule_uid
 

tests/conftest.py

@@ -6,7 +6,7 @@
 from dotenv import load_dotenv
 from mcp.client.sse import sse_client
 from mcp.client.stdio import stdio_client
-from mcp.client.streamable_http import streamablehttp_client
+from mcp.client.streamable_http import create_mcp_http_client, streamable_http_client
 from mcp import ClientSession, StdioServerParameters
 
 load_dotenv()
@@ -119,13 +119,12 @@ async def mcp_client(mcp_transport, mcp_url, grafana_env, grafana_headers):
     elif mcp_transport == "streamable-http":
         # Use HTTP client for streamable-http transport
         url = f"{mcp_url}/mcp"
-        async with streamablehttp_client(url, headers=grafana_headers) as (
-            read,
-            write,
-            _,
+        async with (
+            create_mcp_http_client(headers=grafana_headers) as http_client,
+            streamable_http_client(url, http_client=http_client) as (read, write),
+            ClientSession(read, write) as session,
         ):
-            async with ClientSession(read, write) as session:
-                await session.initialize()
-                yield session
+            await session.initialize()
+            yield session
     else:
         raise ValueError(f"Unsupported transport: {mcp_transport}")

tests/disable_write_test.py

@@ -57,12 +57,12 @@ async def test_disable_write_flag_disables_write_tools(grafana_env):
             # Verify the read-only alerting_rules_read is present
             assert "alerting_rules_read" in tool_names, "alerting_rules_read should be available with --disable-write flag"
             alerting_tool = next(t for t in tools_result.tools if t.name == "alerting_rules_read")
-            assert alerting_tool.annotations.readOnlyHint is True, "alerting_rules_read should be read-only with --disable-write flag"
+            assert alerting_tool.annotations.read_only_hint is True, "alerting_rules_read should be read-only with --disable-write flag"
 
             # Verify the read-only alerting_silences_read is present
             assert "alerting_silences_read" in tool_names, "alerting_silences_read should be available with --disable-write flag"
             silences_tool = next(t for t in tools_result.tools if t.name == "alerting_silences_read")
-            assert silences_tool.annotations.readOnlyHint is True, "alerting_silences_read should be read-only with --disable-write flag"
+            assert silences_tool.annotations.read_only_hint is True, "alerting_silences_read should be read-only with --disable-write flag"
 
             # Verify read tools ARE still present
             read_tools = [
@@ -119,7 +119,7 @@ async def test_without_disable_write_flag_enables_write_tools(grafana_env):
 
             # Verify the read-write alerting_rules_write is present (with destructive hint)
             alerting_tool = next(t for t in tools_result.tools if t.name == "alerting_rules_write")
-            assert alerting_tool.annotations.destructiveHint is True, "alerting_rules_write should be marked destructive without --disable-write flag"
+            assert alerting_tool.annotations.destructive_hint is True, "alerting_rules_write should be marked destructive without --disable-write flag"
 
             # Verify read tools are also present
             read_tools = [

tests/pyproject.toml

@@ -16,7 +16,7 @@ dev = [
     "anyio>=4.9.0",
     "deepeval>=1.0.0",
     "litellm>=1.105.1,<1.106",
-    "mcp>=1.9.3,<2",
+    "mcp>=2.3,<3",
     "pytest>=9.0.3",
     "pytest-rerunfailures>=15.0",
     "python-dotenv>=1.2.2",

tests/rendering_test.py

@@ -36,7 +36,7 @@ async def test_get_panel_image(
         content_item = mcp_tc.result.content[0]
         assert isinstance(content_item, ImageContent)
         assert content_item.type == "image"
-        assert content_item.mimeType == "image/png"
+        assert content_item.mime_type == "image/png"
         assert len(content_item.data) > 0
 
     assert_mcp_eval(

tests/tempo_test.py

@@ -74,21 +74,21 @@ async def test_tempo_tools_have_datasourceUid_parameter(self, mcp_client):
 
         for tool in tempo_tools:
             # Verify the tool has input schema
-            assert hasattr(tool, "inputSchema"), (
+            assert hasattr(tool, "input_schema"), (
                 f"Tool {tool.name} should have inputSchema"
             )
-            assert isinstance(tool.inputSchema, dict), (
+            assert isinstance(tool.input_schema, dict), (
                 f"Tool {tool.name} inputSchema should be a dict"
             )
 
             # Verify datasourceUid parameter exists (camelCase)
-            properties = tool.inputSchema.get("properties", {})
+            properties = tool.input_schema.get("properties", {})
             assert "datasourceUid" in properties, (
                 f"Tool {tool.name} should have datasourceUid parameter (camelCase)"
             )
 
             # Verify it's required
-            required = tool.inputSchema.get("required", [])
+            required = tool.input_schema.get("required", [])
             assert "datasourceUid" in required, (
                 f"Tool {tool.name} should require datasourceUid parameter"
             )
@@ -137,7 +137,7 @@ async def test_tempo_tool_call_missing_datasourceUid(self, mcp_client):
                 arguments={},  # Missing datasourceUid
             )
             # If the server returns an error result instead of raising
-            assert result.isError, "Should return an error when datasourceUid is missing"
+            assert result.is_error, "Should return an error when datasourceUid is missing"
             error_text = result.content[0].text.lower()
             assert "datasourceuid" in error_text or "required" in error_text, (
                 f"Error should mention datasourceUid: {result.content[0].text}"
@@ -158,7 +158,7 @@ async def test_tempo_tool_call_invalid_datasourceUid(self, mcp_client):
                 arguments={"datasourceUid": "nonexistent-tempo"},
             )
             # Server may return an error result rather than raising
-            assert result.isError, "Should return an error for invalid datasourceUid"
+            assert result.is_error, "Should return an error for invalid datasourceUid"
             error_text = result.content[0].text.lower()
             assert "not found" in error_text or "not accessible" in error_text, (
                 f"Should indicate datasource not found: {result.content[0].text}"

tests/utils.py

@@ -21,8 +21,8 @@ def convert_tool(tool: Tool) -> dict:
             "name": tool.name,
             "description": tool.description,
             "parameters": {
-                **tool.inputSchema,
-                "properties": tool.inputSchema.get("properties", {}),
+                **tool.input_schema,
+                "properties": tool.input_schema.get("properties", {}),
             },
         },
     }
@@ -154,7 +154,7 @@ def assert_mcp_eval(
     # Give the output judge the actual tool evidence, not just the user's prompt.
     # Otherwise a correct answer with real logs looks fabricated to GEval.
     tool_results = [
-        f"{tool.name} {'error' if tool.result.isError else 'result'}: {tool_result_text(tool.result)}"
+        f"{tool.name} {'error' if tool.result.is_error else 'result'}: {tool_result_text(tool.result)}"
         for tool in tools_called
     ]
     test_case = LLMTestCase(