Merge pull request #7 from damassi/feat/better-mcp-status

feat: Update mcp server status

Author: damassi

README.md

@@ -34,8 +34,6 @@ make dev
 
 Additional MCP servers are configured in `agent-chat-cli.config.yaml` and prompts added within the `prompts` folder.
 
-Optionally, MCP servers can be lazy-loaded via chat inference, which is useful if you have many MCP servers or MCP servers with many tools; set `mcp_server_inference: true` to enable it.
-
 ## Development
 
 - Install pre-commit hooks via [pre-commit](https://pre-commit.com/)

agent-chat-cli.config.yaml

@@ -8,10 +8,6 @@ model: haiku
 # Enable streaming
 include_partial_messages: true
 
-# Enable dynamic/lazy MCP server inference. Useful if one has many MCP servers or
-# many tools, or is cost conscious about loading everything up front.
-mcp_server_inference: false
-
 # Global tool restrictions
 disallowed_tools: ["Bash"]
 

src/agent_chat_cli/components/header.py

@@ -4,6 +4,7 @@
 
 from agent_chat_cli.components.spacer import Spacer
 from agent_chat_cli.utils.config import load_config
+from agent_chat_cli.utils.mcp_server_status import MCPServerStatus
 
 
 class Header(Widget):
@@ -18,7 +19,8 @@ def compose(self) -> ComposeResult:
         )
 
         yield Label(
-            f"[dim]Available MCP Servers:[/dim] {mcp_servers}",
+            f"[dim]Available MCP Servers: {mcp_servers}[/dim]",
+            id="header-mcp-servers",
         )
 
         if agents:
@@ -35,3 +37,29 @@ def compose(self) -> ComposeResult:
             id="header-instructions",
             classes="header-instructions",
         )
+
+    def on_mount(self) -> None:
+        MCPServerStatus.subscribe(self._handle_mcp_server_status)
+
+    def on_unmount(self) -> None:
+        MCPServerStatus.unsubscribe(self._handle_mcp_server_status)
+
+    def _handle_mcp_server_status(self) -> None:
+        config = load_config()
+        server_names = list(config.mcp_servers.keys())
+
+        server_parts = []
+        for name in server_names:
+            is_connected = MCPServerStatus.is_connected(name)
+
+            if is_connected:
+                server_parts.append(f"{name}")
+            else:
+                # Error connecting to MCP
+                server_parts.append(f"[#ffa2dc][strike]{name}[/strike][/]")
+
+        mcp_servers = ", ".join(server_parts)
+        markup = f"[dim]Available MCP Servers:[/dim] {mcp_servers}"
+
+        label = self.query_one("#header-mcp-servers", Label)
+        label.update(markup)

src/agent_chat_cli/core/agent_loop.py

@@ -8,6 +8,7 @@
 )
 from claude_agent_sdk.types import (
     AssistantMessage,
+    Message,
     SystemMessage,
     TextBlock,
     ToolUseBlock,
@@ -23,8 +24,8 @@
     get_sdk_config,
 )
 from agent_chat_cli.utils.enums import AgentMessageType, ContentType, ControlCommand
-from agent_chat_cli.core.mcp_inference import infer_mcp_servers
 from agent_chat_cli.utils.logger import log_json
+from agent_chat_cli.utils.mcp_server_status import MCPServerStatus
 
 if TYPE_CHECKING:
     from agent_chat_cli.app import AgentChatCLIApp
@@ -46,7 +47,6 @@ def __init__(
         self.config = load_config()
         self.session_id = session_id
         self.available_servers = get_available_servers()
-        self.inferred_servers: set[str] = set()
 
         self.client: ClaudeSDKClient
 
@@ -58,78 +58,33 @@ def __init__(
         self.interrupting = False
 
     async def start(self) -> None:
-        # Boot MCP servers lazily
-        if self.config.mcp_server_inference:
-            await self._initialize_client(mcp_servers={})
-        else:
-            # Boot MCP servers all at once
-            mcp_servers = {
-                name: config.model_dump()
-                for name, config in self.available_servers.items()
-            }
-
-            await self._initialize_client(mcp_servers=mcp_servers)
+        mcp_servers = {
+            name: config.model_dump() for name, config in self.available_servers.items()
+        }
+
+        await self._initialize_client(mcp_servers=mcp_servers)
 
         self._running = True
 
         while self._running:
             user_input = await self.query_queue.get()
 
-            # Check for new convo flags
             if isinstance(user_input, ControlCommand):
                 if user_input == ControlCommand.NEW_CONVERSATION:
-                    self.inferred_servers.clear()
-
-                    await self.client.disconnect()
-
-                    # Reset MCP servers based on config settings
-                    if self.config.mcp_server_inference:
-                        await self._initialize_client(mcp_servers={})
-                    else:
-                        mcp_servers = {
-                            name: config.model_dump()
-                            for name, config in self.available_servers.items()
-                        }
-
-                        await self._initialize_client(mcp_servers=mcp_servers)
-                continue
-
-            # Infer MCP servers based on user messages in chat
-            if self.config.mcp_server_inference:
-                inference_result = await infer_mcp_servers(
-                    user_message=user_input,
-                    available_servers=self.available_servers,
-                    inferred_servers=self.inferred_servers,
-                    session_id=self.session_id,
-                )
-
-                # If there are new results, create an updated mcp_server list
-                if inference_result["new_servers"]:
-                    server_list = ", ".join(inference_result["new_servers"])
-
-                    self.app.actions.post_system_message(
-                        f"Connecting to {server_list}..."
-                    )
-
-                    await asyncio.sleep(0.1)
-
-                    # If there's updates, we reinitialize the agent SDK (with the
-                    # persisted session_id from the turn, stored in the instance)
                     await self.client.disconnect()
 
                     mcp_servers = {
                         name: config.model_dump()
-                        for name, config in inference_result["selected_servers"].items()
+                        for name, config in self.available_servers.items()
                     }
 
                     await self._initialize_client(mcp_servers=mcp_servers)
+                continue
 
             self.interrupting = False
 
-            # Send query
             await self.client.query(user_input)
 
-            # Wait for messages from Claude
             async for message in self.client.receive_response():
                 if self.interrupting:
                     continue
@@ -154,7 +109,7 @@ async def _initialize_client(self, mcp_servers: dict) -> None:
 
         await self.client.connect()
 
-    async def _handle_message(self, message: Any) -> None:
+    async def _handle_message(self, message: Message) -> None:
         if isinstance(message, SystemMessage):
             log_json(message.data)
 
@@ -164,6 +119,9 @@ async def _handle_message(self, message: Any) -> None:
                 # When initializing the chat, we store the session_id for later
                 self.session_id = message.data["session_id"]
 
+                # Report connected / error status back to UI
+                MCPServerStatus.update(message.data["mcp_servers"])
+
         # Handle streaming messages
         if hasattr(message, "event"):
             event = message.event  # type: ignore[attr-defined]
@@ -215,7 +173,7 @@ async def _can_use_tool(
         self,
         tool_name: str,
         tool_input: dict[str, Any],
-        context: ToolPermissionContext,
+        _context: ToolPermissionContext,
     ) -> PermissionResult:
         """Agent SDK handler for tool use permissions"""
 

src/agent_chat_cli/core/mcp_inference.py

@@ -10,7 +10,7 @@ MarkdownH6 {
 }
 
 Screen {
-    background: transparent;
+    background: #222;
 }
 
 Spacer {