Allow MCP servers list to partially initialize

Author: quinlanjager

aider/coders/base_coder.py

@@ -1626,7 +1626,10 @@ async def _execute_all_tool_calls():
         return tool_responses
 
     def initialize_mcp_tools(self):
-        """Initialize tools from all configured MCP servers."""
+        """
+        Initialize tools from all configured MCP servers. MCP Servers that fail to be
+        initialized will not be available to the Coder instance.
+        """
         tools = []
 
         async def get_server_tools(server):
@@ -1636,13 +1639,18 @@ async def get_server_tools(server):
                     session=session, format="openai"
                 )
                 return (server.name, server_tools)
+            except Exception:
+                self.io.tool_warning(
+                    f"Error initializing MCP server {server.name}. A message has been logged."
+                )
+                return None
             finally:
                 await server.disconnect()
 
         async def get_all_server_tools():
             tasks = [get_server_tools(server) for server in self.mcp_servers]
             results = await asyncio.gather(*tasks)
-            return results
+            return [result for result in results if result is not None]
 
         if self.mcp_servers:
             tools = asyncio.run(get_all_server_tools())

tests/basic/test_coder.py

@@ -2,7 +2,7 @@
 import tempfile
 import unittest
 from pathlib import Path
-from unittest.mock import MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import git
 
@@ -575,6 +575,7 @@ def test_new_file_edit_one_commit(self):
             fname = Path("file.txt")
 
             io = InputOutput(yes=True)
+            io.tool_warning = MagicMock()
             coder = Coder.create(self.GPT35, "diff", io=io, fnames=[str(fname)])
 
             self.assertTrue(fname.exists())
@@ -1351,6 +1352,60 @@ def test_mcp_server_connection(self, mock_mcp_client):
                     self.assertEqual(tool_responses[0]["tool_call_id"], "test_id")
                     self.assertEqual(tool_responses[0]["content"], "Tool execution result")
 
+    @patch("aider.coders.base_coder.experimental_mcp_client")
+    def test_coder_creation_with_failed_mcp_server(self, mock_mcp_client):
+        """Test that a coder can still be created even if an MCP server fails to initialize."""
+        with GitTemporaryDirectory():
+            io = InputOutput(yes=True)
+            io.tool_warning = MagicMock()
+
+            # Create mock MCP servers - one working, one failing
+            working_server = AsyncMock()
+            working_server.name = "working_server"
+            working_server.connect = AsyncMock()
+            working_server.disconnect = AsyncMock()
+
+            failing_server = AsyncMock()
+            failing_server.name = "failing_server"
+            failing_server.connect = AsyncMock()
+            failing_server.disconnect = AsyncMock()
+
+            # Mock load_mcp_tools to succeed for working_server and fail for failing_server
+            async def mock_load_mcp_tools(session, format):
+                if session == await working_server.connect():
+                    return [{"function": {"name": "working_tool"}}]
+                else:
+                    raise Exception("Failed to load tools")
+
+            mock_mcp_client.load_mcp_tools = AsyncMock(side_effect=mock_load_mcp_tools)
+
+            # Create coder with both servers
+            coder = Coder.create(
+                self.GPT35,
+                "diff",
+                io=io,
+                mcp_servers=[working_server, failing_server],
+                verbose=True,
+            )
+
+            # Verify that coder was created successfully
+            self.assertIsInstance(coder, Coder)
+
+            # Verify that only the working server's tools were added
+            self.assertIsNotNone(coder.mcp_tools)
+            self.assertEqual(len(coder.mcp_tools), 1)
+            self.assertEqual(coder.mcp_tools[0][0], "working_server")
+
+            # Verify that the tool list contains only working tools
+            tool_list = coder.get_tool_list()
+            self.assertEqual(len(tool_list), 1)
+            self.assertEqual(tool_list[0]["function"]["name"], "working_tool")
+
+            # Verify that the warning was logged for the failing server
+            io.tool_warning.assert_called_with(
+                "Error initializing MCP server failing_server. A message has been logged."
+            )
+
     @patch("aider.coders.base_coder.experimental_mcp_client")
     def test_initialize_mcp_tools(self, mock_mcp_client):
         """Test that the coder initializes MCP tools correctly."""