kiln-ai 0.21.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

kiln_ai/tools/test_mcp_session_manager.py

@@ -8,11 +8,99 @@ from mcp.shared.exceptions import McpError
 from mcp.types import ErrorData
 from pydantic import ValidationError
 
-from kiln_ai.datamodel.external_tool_server import ExternalToolServer, ToolServerType
-from kiln_ai.tools.mcp_session_manager import MCPSessionManager
+from kiln_ai.datamodel.external_tool_server import (
+    ExternalToolServer,
+    ToolServerType,
+)
+from kiln_ai.tools.mcp_session_manager import (
+    LOCAL_MCP_ERROR_INSTRUCTION,
+    MCPSessionManager,
+)
 from kiln_ai.utils.config import MCP_SECRETS_KEY
 
 
+def create_remote_server(
+    headers=None,
+    secret_header_keys=None,
+):
+    """Factory function to create remote MCP servers with configurable properties."""
+    return ExternalToolServer(
+        name="test_server",
+        type=ToolServerType.remote_mcp,
+        description="Test server",
+        properties={
+            "server_url": "http://example.com/mcp",
+            "headers": headers or {},
+            "secret_header_keys": secret_header_keys or [],
+        },
+    )
+
+
+def create_local_server(
+    command="python",
+    args=None,
+    env_vars=None,
+    secret_env_var_keys=None,
+):
+    """Factory function to create local MCP servers with configurable properties."""
+    return ExternalToolServer(
+        name="test_server",
+        type=ToolServerType.local_mcp,
+        description="Test server",
+        properties={
+            "command": command,
+            "args": args or [],
+            "env_vars": env_vars or {},
+            "secret_env_var_keys": secret_env_var_keys or [],
+        },
+    )
+
+
+@pytest.fixture
+def basic_remote_server():
+    return create_remote_server()
+
+
+@pytest.fixture
+def remote_server_with_auth():
+    return create_remote_server(headers={"Authorization": "Bearer token123"})
+
+
+@pytest.fixture
+def basic_local_server():
+    return create_local_server()
+
+
+@pytest.fixture
+def local_server_with_env():
+    """Local MCP server with environment variables."""
+    return create_local_server(
+        args=["-m", "my_mcp_server"],
+        env_vars={"API_KEY": "test123"},
+    )
+
+
+@pytest.fixture
+def remote_server_with_secret_keys():
+    """Remote MCP server with secret header keys."""
+    server = create_remote_server(
+        headers={"Content-Type": "application/json"},
+        secret_header_keys=["Authorization", "X-API-Key"],
+    )
+    return server
+
+
+@pytest.fixture
+def local_server_with_secret_keys():
+    """Local MCP server with secret environment variable keys."""
+    server = create_local_server(
+        args=["-m", "my_server"],
+        env_vars={"PUBLIC_VAR": "public_value"},
+        secret_env_var_keys=["SECRET_API_KEY", "ANOTHER_SECRET"],
+    )
+    return server
+
+
 class TestMCPSessionManager:
     """Unit tests for MCPSessionManager."""
 
@@ -84,8 +172,9 @@ class TestMCPSessionManager:
         manager = MCPSessionManager()
 
         # Create a mock exception-like object with exceptions attribute
-        class MockExceptionGroup:
+        class MockExceptionGroup(Exception):
             def __init__(self, exceptions):
+                super().__init__("Mock exception group")
                 self.exceptions = exceptions
 
         # Test finding target exception in exceptions list
@@ -105,8 +194,9 @@ class TestMCPSessionManager:
         """Test _extract_first_exception with nested objects having exceptions attribute."""
         manager = MCPSessionManager()
 
-        class MockExceptionGroup:
+        class MockExceptionGroup(Exception):
             def __init__(self, exceptions):
+                super().__init__("Mock exception group")
                 self.exceptions = exceptions
 
         # Create nested structure
@@ -131,7 +221,7 @@ class TestMCPSessionManager:
         manager = MCPSessionManager()
 
         # Object without exceptions attribute should return None
-        class MockObject:
+        class MockObject(Exception):
             pass
 
         mock_obj = MockObject()
@@ -142,7 +232,7 @@ class TestMCPSessionManager:
         """Test _extract_first_exception with object that has None exceptions attribute."""
         manager = MCPSessionManager()
 
-        class MockObject:
+        class MockObject(Exception):
             exceptions = None
 
         mock_obj = MockObject()
@@ -153,8 +243,9 @@ class TestMCPSessionManager:
         """Test _extract_first_exception with empty exceptions list."""
         manager = MCPSessionManager()
 
-        class MockExceptionGroup:
+        class MockExceptionGroup(Exception):
             def __init__(self):
+                super().__init__("Mock exception group")
                 self.exceptions = []
 
         mock_group = MockExceptionGroup()
@@ -162,7 +253,9 @@ class TestMCPSessionManager:
         assert result is None
 
     @patch("kiln_ai.tools.mcp_session_manager.streamablehttp_client")
-    async def test_successful_session_creation(self, mock_client):
+    async def test_successful_session_creation(
+        self, mock_client, remote_server_with_auth
+    ):
         """Test successful MCP session creation with mocked client."""
         # Mock the streams
         mock_read_stream = MagicMock()
@@ -175,17 +268,6 @@ class TestMCPSessionManager:
             None,
         )
 
-        # Create a valid tool server
-        tool_server = ExternalToolServer(
-            name="test_server",
-            type=ToolServerType.remote_mcp,
-            description="Test server",
-            properties={
-                "server_url": "http://example.com/mcp",
-                "headers": {"Authorization": "Bearer token123"},
-            },
-        )
-
         manager = MCPSessionManager.shared()
 
         with patch(
@@ -196,7 +278,7 @@ class TestMCPSessionManager:
                 mock_session_instance
             )
 
-            async with manager.mcp_client(tool_server) as session:
+            async with manager.mcp_client(remote_server_with_auth) as session:
                 # Verify session is returned
                 assert session is mock_session_instance
 
@@ -209,7 +291,7 @@ class TestMCPSessionManager:
         )
 
     @patch("kiln_ai.tools.mcp_session_manager.streamablehttp_client")
-    async def test_session_with_empty_headers(self, mock_client):
+    async def test_session_with_empty_headers(self, mock_client, basic_remote_server):
         """Test session creation when empty headers dict is provided."""
         # Mock the streams
         mock_read_stream = MagicMock()
@@ -222,16 +304,10 @@ class TestMCPSessionManager:
             None,
         )
 
-        # Create a tool server with empty headers
-        tool_server = ExternalToolServer(
-            name="empty_headers_server",
-            type=ToolServerType.remote_mcp,
-            description="Server with empty headers",
-            properties={
-                "server_url": "http://example.com/mcp",
-                "headers": {},  # Empty headers dict is required by pydantic
-            },
-        )
+        # Use basic server with empty headers
+        tool_server = basic_remote_server
+        tool_server.name = "empty_headers_server"
+        tool_server.description = "Server with empty headers"
 
         manager = MCPSessionManager.shared()
 
@@ -262,7 +338,7 @@ class TestMCPSessionManager:
     )
     @patch("kiln_ai.tools.mcp_session_manager.streamablehttp_client")
     async def test_remote_mcp_http_status_errors(
-        self, mock_client, status_code, reason_phrase
+        self, mock_client, status_code, reason_phrase, basic_remote_server
     ):
         """Test remote MCP session handles various HTTP status errors with simplified message."""
         # Create HTTP error with specific status code
@@ -276,13 +352,6 @@ class TestMCPSessionManager:
         # Mock client to raise the HTTP error
         mock_client.return_value.__aenter__.side_effect = http_error
 
-        tool_server = ExternalToolServer(
-            name="test_server",
-            type=ToolServerType.remote_mcp,
-            description="Test server",
-            properties={"server_url": "http://example.com/mcp", "headers": {}},
-        )
-
         manager = MCPSessionManager.shared()
 
         # All HTTP errors should now use the simplified message format
@@ -290,7 +359,7 @@ class TestMCPSessionManager:
         with pytest.raises(
             ValueError, match=expected_pattern.replace("(", r"\(").replace(")", r"\)")
         ):
-            async with manager.mcp_client(tool_server):
+            async with manager.mcp_client(basic_remote_server):
                 pass
 
     @pytest.mark.parametrize(
@@ -304,7 +373,7 @@ class TestMCPSessionManager:
     )
     @patch("kiln_ai.tools.mcp_session_manager.streamablehttp_client")
     async def test_remote_mcp_connection_errors(
-        self, mock_client, connection_error_type, error_message
+        self, mock_client, connection_error_type, error_message, basic_remote_server
     ):
         """Test remote MCP session handles various connection errors with simplified message."""
         # Create connection error
@@ -318,22 +387,17 @@ class TestMCPSessionManager:
         # Mock client to raise the connection error
         mock_client.return_value.__aenter__.side_effect = connection_error
 
-        tool_server = ExternalToolServer(
-            name="test_server",
-            type=ToolServerType.remote_mcp,
-            description="Test server",
-            properties={"server_url": "http://example.com/mcp", "headers": {}},
-        )
-
         manager = MCPSessionManager.shared()
 
         # All connection errors should use the simplified message format
         with pytest.raises(RuntimeError, match="Unable to connect to MCP server"):
-            async with manager.mcp_client(tool_server):
+            async with manager.mcp_client(basic_remote_server):
                 pass
 
     @patch("kiln_ai.tools.mcp_session_manager.streamablehttp_client")
-    async def test_remote_mcp_http_error_in_nested_exceptions(self, mock_client):
+    async def test_remote_mcp_http_error_in_nested_exceptions(
+        self, mock_client, basic_remote_server
+    ):
         """Test remote MCP session extracts HTTP error from nested exceptions."""
         # Create HTTP error nested in a mock exception group
         response = MagicMock()
@@ -353,24 +417,19 @@ class TestMCPSessionManager:
         # Mock client to raise the nested exception
         mock_client.return_value.__aenter__.side_effect = group_error
 
-        tool_server = ExternalToolServer(
-            name="test_server",
-            type=ToolServerType.remote_mcp,
-            description="Test server",
-            properties={"server_url": "http://example.com/mcp", "headers": {}},
-        )
-
         manager = MCPSessionManager.shared()
 
         # Should extract the HTTP error from the nested structure
         with pytest.raises(
             ValueError, match=r"The MCP server rejected the request. Status 401"
         ):
-            async with manager.mcp_client(tool_server):
+            async with manager.mcp_client(basic_remote_server):
                 pass
 
     @patch("kiln_ai.tools.mcp_session_manager.streamablehttp_client")
-    async def test_remote_mcp_connection_error_in_nested_exceptions(self, mock_client):
+    async def test_remote_mcp_connection_error_in_nested_exceptions(
+        self, mock_client, basic_remote_server
+    ):
         """Test remote MCP session extracts connection error from nested exceptions."""
         # Create connection error nested in mock exception group
         connection_error = ConnectionError("Connection timeout")
@@ -385,44 +444,34 @@ class TestMCPSessionManager:
         # Mock client to raise the nested exception
         mock_client.return_value.__aenter__.side_effect = group_error
 
-        tool_server = ExternalToolServer(
-            name="test_server",
-            type=ToolServerType.remote_mcp,
-            description="Test server",
-            properties={"server_url": "http://example.com/mcp", "headers": {}},
-        )
-
         manager = MCPSessionManager.shared()
 
         # Should extract the connection error from the nested structure
         with pytest.raises(RuntimeError, match="Unable to connect to MCP server"):
-            async with manager.mcp_client(tool_server):
+            async with manager.mcp_client(basic_remote_server):
                 pass
 
     @patch("kiln_ai.tools.mcp_session_manager.streamablehttp_client")
-    async def test_remote_mcp_unknown_error_fallback(self, mock_client):
+    async def test_remote_mcp_unknown_error_fallback(
+        self, mock_client, basic_remote_server
+    ):
         """Test remote MCP session handles unknown errors with fallback message."""
         # Mock client to raise an unknown error type
         unknown_error = RuntimeError("Unexpected error")
         mock_client.return_value.__aenter__.side_effect = unknown_error
 
-        tool_server = ExternalToolServer(
-            name="test_server",
-            type=ToolServerType.remote_mcp,
-            description="Test server",
-            properties={"server_url": "http://example.com/mcp", "headers": {}},
-        )
-
         manager = MCPSessionManager.shared()
 
         # Should use the fallback error message
         with pytest.raises(RuntimeError, match="Failed to connect to the MCP Server"):
-            async with manager.mcp_client(tool_server):
+            async with manager.mcp_client(basic_remote_server):
                 pass
 
     @patch("kiln_ai.tools.mcp_session_manager.streamablehttp_client")
     @patch("kiln_ai.utils.config.Config.shared")
-    async def test_session_with_secret_headers(self, mock_config, mock_client):
+    async def test_session_with_secret_headers(
+        self, mock_config, mock_client, remote_server_with_secret_keys
+    ):
         """Test session creation with secret headers retrieved from config."""
         # Mock the streams
         mock_read_stream = MagicMock()
@@ -444,19 +493,10 @@ class TestMCPSessionManager:
         }
         mock_config.return_value = mock_config_instance
 
-        # Create a tool server with secret header keys
-        tool_server = ExternalToolServer(
-            name="secret_headers_server",
-            type=ToolServerType.remote_mcp,
-            description="Server with secret headers",
-            properties={
-                "server_url": "http://example.com/mcp",
-                "headers": {"Content-Type": "application/json"},
-                "secret_header_keys": ["Authorization", "X-API-Key"],
-            },
-        )
-        # Set the server ID to match our mock secrets
-        tool_server.id = "test_server_id"
+        tool_server = remote_server_with_secret_keys
+        tool_server.id = "test_server_id"  # Set the id
+        tool_server.name = "secret_headers_server"
+        tool_server.description = "Server with secret headers"
 
         manager = MCPSessionManager.shared()
 
@@ -726,7 +766,7 @@ class TestMCPSessionManager:
         tool_server.id = "test_server_id"
 
         # Store original headers for comparison
-        original_headers = tool_server.properties["headers"].copy()
+        original_headers = tool_server.properties.get("headers", {}).copy()
 
         manager = MCPSessionManager.shared()
 
@@ -743,18 +783,20 @@ class TestMCPSessionManager:
                 assert session is mock_session_instance
 
             # Check that original headers are unchanged after first use
-            assert tool_server.properties["headers"] == original_headers
-            assert "Authorization" not in tool_server.properties["headers"]
-            assert "X-API-Key" not in tool_server.properties["headers"]
+            headers = tool_server.properties.get("headers", {})
+            assert headers == original_headers
+            assert "Authorization" not in headers
+            assert "X-API-Key" not in headers
 
             # Use the session a second time to ensure the bug doesn't occur on subsequent uses
             async with manager.mcp_client(tool_server) as session:
                 assert session is mock_session_instance
 
             # Check that original headers are still unchanged after second use
-            assert tool_server.properties["headers"] == original_headers
-            assert "Authorization" not in tool_server.properties["headers"]
-            assert "X-API-Key" not in tool_server.properties["headers"]
+            headers = tool_server.properties.get("headers", {})
+            assert headers == original_headers
+            assert "Authorization" not in headers
+            assert "X-API-Key" not in headers
 
         # Verify streamablehttp_client was called with merged headers both times
         expected_headers = {
@@ -807,7 +849,7 @@ class TestMCPSessionManager:
         tool_server.id = "test_server_id"
 
         # Store original headers for comparison
-        original_headers = tool_server.properties["headers"].copy()
+        original_headers = tool_server.properties.get("headers", {}).copy()
 
         # Simulate the buggy behavior by directly modifying the headers
         # (This is what would happen without the .copy() fix)
@@ -825,18 +867,17 @@ class TestMCPSessionManager:
                         buggy_headers[header_name] = header_value
 
         # Now the original properties would be contaminated with secrets!
-        assert "Authorization" in tool_server.properties["headers"]
-        assert (
-            tool_server.properties["headers"]["Authorization"]
-            == "Bearer secret-token-123"
-        )
+        headers = tool_server.properties.get("headers", {})
+        assert "Authorization" in headers
+        assert headers["Authorization"] == "Bearer secret-token-123"
 
         # This demonstrates the security bug - secrets are now permanently stored
         # in the tool server properties and would be serialized/saved
-        assert tool_server.properties["headers"] != original_headers
+        headers = tool_server.properties.get("headers", {})
+        assert headers != original_headers
 
     @patch("kiln_ai.tools.mcp_session_manager.stdio_client")
-    async def test_local_mcp_session_creation(self, mock_client):
+    async def test_local_mcp_session_creation(self, mock_client, local_server_with_env):
         """Test successful local MCP session creation with mocked client."""
         # Mock the streams
         mock_read_stream = MagicMock()
@@ -848,18 +889,6 @@ class TestMCPSessionManager:
             mock_write_stream,
         )
 
-        # Create a valid local tool server
-        tool_server = ExternalToolServer(
-            name="test_local_server",
-            type=ToolServerType.local_mcp,
-            description="Test local server",
-            properties={
-                "command": "python",
-                "args": ["-m", "my_mcp_server"],
-                "env_vars": {"API_KEY": "test123"},
-            },
-        )
-
         manager = MCPSessionManager.shared()
 
         with patch(
@@ -870,7 +899,7 @@ class TestMCPSessionManager:
                 mock_session_instance
             )
 
-            async with manager.mcp_client(tool_server) as session:
+            async with manager.mcp_client(local_server_with_env) as session:
                 # Verify session is returned
                 assert session is mock_session_instance
 
@@ -937,36 +966,19 @@ class TestMCPSessionManager:
         """Test that missing command raises ValueError for local MCP."""
         with pytest.raises(
             ValidationError,
-            match="command must be a string to start a local MCP server",
+            match="command must be a non-empty string",
         ):
             ExternalToolServer(
                 name="missing_command_server",
                 type=ToolServerType.local_mcp,
                 description="Server missing command",
                 properties={
-                    # No command provided
+                    "command": "",  # Empty command to trigger validation error
                     "args": ["arg1"],
                     "env_vars": {},
                 },
             )
 
-    async def test_local_mcp_missing_args_error(self):
-        """Test that missing args raises ValueError for local MCP."""
-        with pytest.raises(
-            ValidationError,
-            match="arguments must be a list to start a local MCP server",
-        ):
-            ExternalToolServer(
-                name="missing_args_server",
-                type=ToolServerType.local_mcp,
-                description="Server missing args",
-                properties={
-                    "command": "python",
-                    # No args provided
-                    "env_vars": {},
-                },
-            )
-
     async def test_local_mcp_empty_args_allowed(self):
         """Test that empty args list is now allowed for local MCP."""
         # Should not raise any exception - empty args are now allowed
@@ -983,63 +995,14 @@ class TestMCPSessionManager:
 
         assert tool_server.name == "empty_args_server"
         assert tool_server.type == ToolServerType.local_mcp
-        assert tool_server.properties["args"] == []
-
-    async def test_local_mcp_session_empty_command_runtime_error(self):
-        """Test that empty command string raises ValueError during session creation."""
-        # Create a valid tool server first
-        tool_server = ExternalToolServer(
-            name="test_server",
-            type=ToolServerType.local_mcp,
-            description="Test server",
-            properties={
-                "command": "python",
-                "args": ["arg1"],
-                "env_vars": {},
-            },
-        )
-
-        # Manually modify the properties after creation to bypass pydantic validation
-        tool_server.properties["command"] = ""
-
-        manager = MCPSessionManager.shared()
-
-        with pytest.raises(
-            ValueError,
-            match="Attempted to start local MCP server, but no command was provided",
-        ):
-            async with manager.mcp_client(tool_server):
-                pass
-
-    async def test_local_mcp_session_invalid_args_type_runtime_error(self):
-        """Test that non-list args raises ValueError during session creation."""
-        # Create a valid tool server first
-        tool_server = ExternalToolServer(
-            name="test_server",
-            type=ToolServerType.local_mcp,
-            description="Test server",
-            properties={
-                "command": "python",
-                "args": ["arg1"],
-                "env_vars": {},
-            },
-        )
-
-        # Manually modify the properties after creation to bypass pydantic validation
-        tool_server.properties["args"] = "not a list"
-
-        manager = MCPSessionManager.shared()
-
-        with pytest.raises(
-            ValueError,
-            match="Attempted to start local MCP server, but args is not a list of strings",
-        ):
-            async with manager.mcp_client(tool_server):
-                pass
+        args = tool_server.properties.get("args", [])
+        assert args == []
 
     @patch("kiln_ai.tools.mcp_session_manager.stdio_client")
     @patch("kiln_ai.utils.config.Config.shared")
-    async def test_local_mcp_session_with_secrets(self, mock_config, mock_client):
+    async def test_local_mcp_session_with_secrets(
+        self, mock_config, mock_client, local_server_with_secret_keys
+    ):
         """Test local MCP session creation with secret environment variables."""
         # Mock config to return different values based on the key
         mock_config_instance = MagicMock()
@@ -1067,19 +1030,7 @@ class TestMCPSessionManager:
             mock_write_stream,
         )
 
-        # Create a tool server with secret env var keys
-        tool_server = ExternalToolServer(
-            name="test_server",
-            type=ToolServerType.local_mcp,
-            description="Test server with secrets",
-            properties={
-                "command": "python",
-                "args": ["-m", "my_server"],
-                "env_vars": {"PUBLIC_VAR": "public_value"},
-                "secret_env_var_keys": ["SECRET_API_KEY", "ANOTHER_SECRET"],
-            },
-        )
-        # Set the server ID to match our mock secrets
+        tool_server = local_server_with_secret_keys
         tool_server.id = "test_server_id"
 
         manager = MCPSessionManager.shared()
@@ -1139,7 +1090,7 @@ class TestMCPSessionManager:
     )
     @patch("kiln_ai.tools.mcp_session_manager.stdio_client")
     async def test_local_mcp_various_errors_use_simplified_message(
-        self, mock_client, error_type, error_message
+        self, mock_client, error_type, error_message, basic_local_server
     ):
         """Test local MCP session handles various errors with simplified message."""
         # Create the appropriate error
@@ -1152,22 +1103,11 @@ class TestMCPSessionManager:
         # Mock client to raise the error
         mock_client.return_value.__aenter__.side_effect = test_error
 
-        tool_server = ExternalToolServer(
-            name="test_server",
-            type=ToolServerType.local_mcp,
-            description="Test server",
-            properties={
-                "command": "python",
-                "args": ["-m", "my_server"],
-                "env_vars": {},
-            },
-        )
-
         manager = MCPSessionManager.shared()
 
         # All local errors should now use the simplified message format
-        with pytest.raises(RuntimeError, match="MCP server failed to start"):
-            async with manager.mcp_client(tool_server):
+        with pytest.raises(RuntimeError, match=LOCAL_MCP_ERROR_INSTRUCTION):
+            async with manager.mcp_client(basic_local_server):
                 pass
 
     @patch("kiln_ai.tools.mcp_session_manager.stdio_client")
@@ -1201,7 +1141,7 @@ class TestMCPSessionManager:
         manager = MCPSessionManager.shared()
 
         # Should extract the McpError from the nested structure and use simplified message
-        with pytest.raises(RuntimeError, match="MCP server failed to start"):
+        with pytest.raises(RuntimeError, match=LOCAL_MCP_ERROR_INSTRUCTION):
             async with manager.mcp_client(tool_server):
                 pass
 
@@ -1219,14 +1159,10 @@ class TestMCPSessionManager:
 
         for original_error in test_exceptions:
             with pytest.raises(RuntimeError) as exc_info:
-                manager._raise_local_mcp_error(original_error)
+                manager._raise_local_mcp_error(original_error, "")
 
             # Check that the error message contains expected text
-            assert "MCP server failed to start" in str(exc_info.value)
-            assert (
-                "Please verify your command, arguments, and environment variables"
-                in str(exc_info.value)
-            )
+            assert LOCAL_MCP_ERROR_INSTRUCTION in str(exc_info.value)
             assert str(original_error) in str(exc_info.value)
 
             # Check that the original exception is chained
@@ -1531,6 +1467,31 @@ class TestMCPSessionManager:
         assert result2 == "/cached/path"
         assert mock_run.call_count == 1  # Should not have been called again
 
+    async def test_mcp_client_with_kiln_task_raises_error(self):
+        """Test that mcp_client raises ValueError when passed a Kiln task tool server."""
+        # Create a Kiln task tool server
+        kiln_task_server = ExternalToolServer(
+            name="test_kiln_task",
+            type=ToolServerType.kiln_task,
+            description="Test Kiln task",
+            properties={
+                "task_id": "task_123",
+                "run_config_id": "config_456",
+                "name": "test_task",
+                "description": "A test task for validation",
+                "is_archived": False,
+            },
+        )
+
+        manager = MCPSessionManager.shared()
+
+        # Should raise ValueError with specific message
+        with pytest.raises(
+            ValueError, match="Kiln task tools are not available from an MCP server"
+        ):
+            async with manager.mcp_client(kiln_task_server):
+                pass
+
 
 class TestMCPServerIntegration:
     """Integration tests for MCPServer using real services."""
@@ -1546,7 +1507,6 @@ class TestMCPServerIntegration:
             description="Postman Echo MCP Server for testing",
             properties={
                 "server_url": "https://postman-echo-mcp.fly.dev/",
-                "headers": {},
             },
         )