cecli-dev 1.2.3rc3__tar.gz → 1.2.3rc4__tar.gz

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.2.3rc3
+Version: 1.2.3rc4
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.3rc3'
-__version_tuple__ = version_tuple = (1, 2, 3, 'rc3')
+__version__ = version = '1.2.3rc4'
+__version_tuple__ = version_tuple = (1, 2, 3, 'rc4')
 
-__commit_id__ = commit_id = 'g3477cad89'
+__commit_id__ = commit_id = 'g0cce57c1b'

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli/coders/base_coder.py

@@ -3363,7 +3363,7 @@ class Coder(metaclass=UsageMeta):
                     continue
 
                 for tool in server_tools:
-                    if server_name == "Local":
+                    if server_name.lower() == "local":
                         # Apply per-instance tool name filtering
                         tool_name = tool.get("function", {}).get("name", "")
                         if (

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli/commands/load_mcp.py

@@ -60,13 +60,13 @@ class LoadMcpCommand(BaseCommand):
         # This moves them from "implicitly include all" to explicit state-machine
         # management, preventing the new server from being implicitly available
         # to all coders.
-        connected_names = {s.name for s in coder.mcp_manager.connected_servers}
+        connected_names = {s.name.lower() for s in coder.mcp_manager.connected_servers}
         if connected_names:
             for c in iter_all_coders(coder):
                 if not c.registered_servers["included"]:
                     included = set(connected_names) - c.registered_servers["excluded"]
                     if c.edit_format in ("agent", "subagent"):
-                        included.add("Local")  # "local" is always available
+                        included.add("local")  # "local" is always available
                     c.registered_servers["included"] = included
 
         # Process connections with interrupt support

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli/commands/remove_mcp.py

@@ -49,7 +49,7 @@ class RemoveMcpCommand(BaseCommand):
             server_name = item.name if hasattr(item, "name") else item
 
             # Never remove the "local" server
-            if server_name == "Local":
+            if server_name.lower() == "local":
                 results.append("Cannot remove 'Local' server")
                 continue
 

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli/commands/utils/helpers.py

@@ -348,7 +348,7 @@ def update_server_registration(coder, server_name, operation, force=False):
                When False, respect the opposing set (excluded wins
                for include, included wins for exclude).
     """
-    name = server_name
+    name = server_name.lower()
     included = coder.registered_servers["included"]
     excluded = coder.registered_servers["excluded"]
 
@@ -379,7 +379,7 @@ def is_server_globally_excluded(coder, server_name):
     Returns:
         True if the server is excluded from every coder.
     """
-    name = server_name
+    name = server_name.lower()
     for other in iter_all_coders(coder):
         incl = other.registered_servers["included"]
         excl = other.registered_servers["excluded"]

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli/helpers/agents/service.py

@@ -565,11 +565,19 @@ class AgentService:
         )
 
         if agent_config:
+            # Reset the per-instance tool/server filters so AgentCoder.post_init()
+            # rebuilds them from *this* sub-agent's own agent-config (tools_includelist/
+            # excludelist, servers_includelist/excludelist) instead of inheriting the
+            # parent's filters verbatim. Deliberately do NOT reset mcp_manager here:
+            # doing so used to discard the parent's already-connected MCP servers and
+            # replace them with a brand new, empty manager, making it impossible for a
+            # sub-agent's servers_includelist to ever match anything. Leaving mcp_manager
+            # unset lets it inherit from from_coder (see Coder.create()) so the same
+            # connected MCP servers remain available and can then be filtered.
             kwargs.update(
                 dict(
                     registered_tools=None,
                     registered_servers=None,
-                    mcp_manager=None,
                 )
             )
 

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli/helpers/responses.py

@@ -366,11 +366,18 @@ def unprefix_tool_call(tool_call):
     return server_name, result
 
 
-def parse_tool_arguments(args_string: str) -> dict:
+def parse_tool_arguments(args_string: str) -> dict | list:
     """Parse tool-call arguments, merging glued ``{…}{} {…}`` object fragments.
 
     Also unwraps a single ``arguments``/``parameters``/``params`` wrapper key
     that some models emit when mirroring the OpenAI wire format.
+
+    Returns a dict in almost all cases. A bare top-level JSON array (e.g. a
+    model emitting ``[...]`` directly as the arguments instead of wrapping it
+    under the tool's single required array parameter, as EditFile's `edits`
+    or ReadFile's `read`) is returned as-is rather than collapsed to ``{}``,
+    so ``BaseTool.process_response`` can still wrap it using the tool's
+    schema instead of silently losing the data.
     """
     text = (args_string or "").strip()
     if not text:
@@ -379,6 +386,8 @@ def parse_tool_arguments(args_string: str) -> dict:
         parsed = json.loads(text)
         if isinstance(parsed, dict):
             return coerce_tool_structure(parsed)
+        if isinstance(parsed, list):
+            return parsed
     except json.JSONDecodeError:
         pass
 
@@ -393,12 +402,18 @@ def parse_tool_arguments(args_string: str) -> dict:
         lone = try_parse_json_value(chunks[0])
         if isinstance(lone, dict):
             return coerce_tool_structure(lone)
+        if isinstance(lone, list):
+            return lone
         try:
             json_string = json_repair.repair_json(chunks[0], ensure_ascii=False)
             single = json.loads(json_string)
         except json.JSONDecodeError as err:
             return {"@error": f"Malformed JSON arguments: {err}"}
-        return coerce_tool_structure(single) if isinstance(single, dict) else {}
+        if isinstance(single, dict):
+            return coerce_tool_structure(single)
+        if isinstance(single, list):
+            return single
+        return {}
 
     merged = merge_glued_json_objects(chunks)
 

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli/mcp/manager.py

@@ -99,7 +99,7 @@ class McpServerManager:
             The server instance or None if not found
         """
         try:
-            return next(server for server in self._servers if server.name == name)
+            return next(server for server in self._servers if server.name.lower() == name.lower())
         except StopIteration:
             return None
 
@@ -254,7 +254,7 @@ class McpServerManager:
         """
         existing_server = self.get_server(server.name)
         if existing_server:
-            if server.name not in ["unnamed-server", "Local"]:
+            if server.name.lower() not in ["unnamed-server", "local"]:
                 self._log_warning(f"MCP server with name '{server.name}' already exists")
             return False
 
@@ -332,7 +332,7 @@ class McpServerManager:
 
         results = await asyncio.gather(*tasks)
         for server, did_connect in results:
-            if not did_connect and server.name not in ["unnamed-server", "Local"]:
+            if not did_connect and server.name.lower() not in ["unnamed-server", "local"]:
                 io.tool_warning(
                     f"MCP tool initialization failed after multiple retries: {server.name}"
                 )

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli/mcp/server.py

@@ -54,7 +54,7 @@ class McpServer:
             verbose: Whether to output verbose logging
         """
         self.config = server_config
-        self.name = server_config.get("name", "unnamed-server")
+        self.name = str(server_config.get("name", "unnamed-server")).lower()
         self.io = io
         self.verbose = verbose
         self.session = None

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli/tools/command.py

@@ -722,6 +722,14 @@ class Tool(BaseTool):
         elif command:
             coder.io.tool_output(f"{color_start}Command:{color_end}")
             coder.io.tool_output(coder.format_command_with_prefix(command))
+        else:
+            # No command and no background_key/action pair: this call will
+            # be rejected by execute() before it ever reaches confirmation.
+            # Say so explicitly instead of leaving the panel looking blank,
+            # which is otherwise indistinguishable from a display bug.
+            coder.io.tool_output(
+                f"{color_start}(no command provided — call will be rejected){color_end}"
+            )
 
         coder.io.tool_output("")
 

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli/tools/resource_manager.py

@@ -199,15 +199,15 @@ class Tool(BaseTool):
         # included sets to explicit include lists.
         if load_mcp_servers and coder.mcp_manager:
             if isinstance(coder.mcp_manager.connected_servers, dict):
-                connected_names = set(coder.mcp_manager.connected_servers.keys())
+                connected_names = {k.lower() for k in coder.mcp_manager.connected_servers.keys()}
             else:
-                connected_names = {s.name for s in coder.mcp_manager.connected_servers}
+                connected_names = {s.name.lower() for s in coder.mcp_manager.connected_servers}
             if connected_names:
                 for c in iter_all_coders(coder):
                     if not c.registered_servers["included"]:
                         included = set(connected_names) - c.registered_servers["excluded"]
                         if c.edit_format in ("agent", "subagent"):
-                            included.add("Local")
+                            included.add("local")
                         c.registered_servers["included"] = included
 
         for f in create_files:
@@ -546,7 +546,7 @@ class Tool(BaseTool):
             if not coder.mcp_manager or not coder.mcp_manager.servers:
                 return "No MCP servers are configured."
 
-            if server_name == "Local":
+            if server_name.lower() == "local":
                 return "Cannot remove 'Local' server"
 
             server = coder.mcp_manager.get_server(server_name)

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli/tools/utils/base_tool.py

@@ -63,25 +63,29 @@ class BaseTool(ABC):
                 required_params = function_schema["parameters"]["required"]
                 properties = function_schema["parameters"].get("properties", {})
 
-                # Auto-correction: If a required parameter is missing but it's an array,
-                # and the current params look like a single item of that array, wrap it.
-                if len(required_params) == 1:
-                    missing_param = required_params[0]
-                    if missing_param not in params and params:
-                        param_schema = properties.get(missing_param, {})
-                        if param_schema.get("type") == "array":
-                            params = {missing_param: [params]}
+                # Auto-correction: fix common shape mistakes (a bare array or
+                # a single item of that array sent directly as the whole
+                # arguments, instead of wrapped under the expected key) BEFORE
+                # checking for missing required parameters. Otherwise a
+                # recoverable shape (e.g. a bare `[...]` array) gets rejected
+                # before it has a chance to be normalized.
+                params = ToolValidations._basic_validations(params, cls.SCHEMA)
 
                 # Auto-correction: If a required parameter is present but is a dict instead of an array
-                for param_name in required_params:
-                    if param_name in params:
-                        param_schema = properties.get(param_name, {})
-                        if param_schema.get("type") == "array" and isinstance(
-                            params[param_name], dict
-                        ):
-                            params[param_name] = [params[param_name]]
-
-                missing_params = [param for param in required_params if param not in params]
+                if isinstance(params, dict):
+                    for param_name in required_params:
+                        if param_name in params:
+                            param_schema = properties.get(param_name, {})
+                            if param_schema.get("type") == "array" and isinstance(
+                                params[param_name], dict
+                            ):
+                                params[param_name] = [params[param_name]]
+
+                missing_params = [
+                    param
+                    for param in required_params
+                    if not isinstance(params, dict) or param not in params
+                ]
                 if missing_params:
                     tool_name = function_schema.get("name", "Unknown Tool")
                     error_msg = (

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli/tools/validations/validations.py

@@ -204,16 +204,28 @@ class ToolValidations:
 
         parameters = function_schema["parameters"]
         properties = parameters.get("properties", {})
-
-        # Only auto-correct when there is exactly one property and it is an array
-        if len(properties) == 1:
+        required = parameters.get("required", [])
+
+        # Determine the single array-typed parameter to auto-correct into,
+        # if any. Prefer the schema's `required` list (covers tools that also
+        # declare optional properties alongside their one required array,
+        # e.g. EditFile's optional `change_id`); fall back to "exactly one
+        # property total" when the schema doesn't declare `required` at all.
+        single_param_name = None
+        if len(required) == 1:
+            single_param_name = required[0]
+        elif not required and len(properties) == 1:
             single_param_name = next(iter(properties.keys()))
-            param_schema = properties[single_param_name]
+
+        if single_param_name is not None:
+            param_schema = properties.get(single_param_name, {})
             if param_schema.get("type") == "array":
-                # Case 1: LLM emitted the array directly (bare list)
+                # Case 1: LLM emitted the array directly (bare list) → wrap
+                # it as-is under the expected key, don't nest it again.
                 if isinstance(params, list):
                     return {single_param_name: params}
-                # Case 2: LLM emitted a dict missing the expected key → wrap it
+                # Case 2: LLM emitted a single item of the array directly
+                # as a dict, missing the expected wrapper key → wrap it.
                 if isinstance(params, dict) and single_param_name not in params:
                     return {single_param_name: [params]}
 

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.2.3rc3
+Version: 1.2.3rc4
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli_dev.egg-info/SOURCES.txt

@@ -787,6 +787,7 @@ tests/mcp/test_keepalive_resilience.py
 tests/mcp/test_keepalive_unit.py
 tests/mcp/test_manager.py
 tests/mcp/test_manager_retry.py
+tests/mcp/test_server_name_normalization.py
 tests/mcp/test_server_sdk_compat.py
 tests/scrape/test_playwright_disable.py
 tests/scrape/test_scrape.py
@@ -799,6 +800,7 @@ tests/subagents/test_finished.py
 tests/subagents/test_io_proxy.py
 tests/subagents/test_service.py
 tests/subagents/test_sub_agent_coder.py
+tests/tools/test_command_format_output.py
 tests/tools/test_edit_file_format_output.py
 tests/tools/test_extractions.py
 tests/tools/test_get_lines.py

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc4}/cecli_dev.egg-info/scm_file_list.json

@@ -1028,6 +1028,7 @@
     "tests/mcp/test_keepalive_unit.py",
     "tests/mcp/test_manager.py",
     "tests/mcp/test_manager_retry.py",
+    "tests/mcp/test_server_name_normalization.py",
     "tests/mcp/test_server_sdk_compat.py",
     "tests/scrape/test_playwright_disable.py",
     "tests/scrape/test_scrape.py",
@@ -1041,6 +1042,7 @@
     "tests/subagents/test_service.py",
     "tests/subagents/test_sub_agent_coder.py",
     "tests/test_requests.py",
+    "tests/tools/test_command_format_output.py",
     "tests/tools/test_edit_file_format_output.py",
     "tests/tools/test_extractions.py",
     "tests/tools/test_get_lines.py",

cecli_dev-1.2.3rc4/cecli_dev.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.2.3rc4",
+  "distance": 0,
+  "node": "g0cce57c1b8208c7067fb545241fa84b5bf17f790",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-19"
+}

cecli_dev-1.2.3rc4/tests/mcp/test_server_name_normalization.py

@@ -0,0 +1,240 @@
+"""Tests for lowercase-normalized MCP server names.
+
+MCP server names are normalized to lowercase at the registration source
+(``McpServer`` construction, ``update_server_registration``, and the
+load/remove-mcp include-set conversions) so that all per-coder filtering
+comparisons can be plain exact matches.
+"""
+
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from cecli.coders import Coder
+from cecli.coders.agent_coder import AgentCoder
+from cecli.commands import SwitchCoderSignal
+from cecli.commands.load_mcp import LoadMcpCommand
+from cecli.commands.utils.helpers import (
+    is_server_globally_excluded,
+    update_server_registration,
+)
+from cecli.mcp.manager import McpServerManager
+from cecli.mcp.server import LocalServer, McpServer
+
+
+def _tool(name):
+    """Build a minimal OpenAI-style function tool dict."""
+    return {
+        "type": "function",
+        "function": {"name": name, "description": "", "parameters": {}},
+    }
+
+
+class TestMcpServerNameLowercasedAtSource:
+    """McpServer names are lowercased at construction time."""
+
+    def test_mcp_server_name_lowercased(self):
+        assert McpServer({"name": "GitHub"}).name == "github"
+
+    def test_local_server_name_lowercased(self):
+        assert LocalServer({"name": "Local"}).name == "local"
+
+    def test_default_name_stays_lowercase(self):
+        assert McpServer({}).name == "unnamed-server"
+
+
+class TestGetServerCaseInsensitive:
+    """Manager lookups tolerate any case, matching normalized names."""
+
+    def test_get_server_matches_any_case(self):
+        server = McpServer({"name": "GitHub"})
+        manager = McpServerManager(servers=[server])
+
+        assert manager.get_server("GitHub") is server
+        assert manager.get_server("github") is server
+        assert manager.get_server("GITHUB") is server
+
+    def test_get_server_missing_returns_none(self):
+        manager = McpServerManager(servers=[McpServer({"name": "GitHub"})])
+
+        assert manager.get_server("missing") is None
+
+
+class TestUpdateServerRegistrationLowercases:
+    """Registration writes lowercase names into the per-coder sets."""
+
+    def test_include_lowercases(self):
+        coder = SimpleNamespace(registered_servers={"included": set(), "excluded": set()})
+
+        update_server_registration(coder, "GitHub", "include", force=True)
+
+        assert coder.registered_servers["included"] == {"github"}
+        assert coder.registered_servers["excluded"] == set()
+
+    def test_exclude_lowercases(self):
+        coder = SimpleNamespace(registered_servers={"included": set(), "excluded": set()})
+
+        update_server_registration(coder, "GITHUB", "exclude", force=True)
+
+        assert coder.registered_servers["excluded"] == {"github"}
+        assert coder.registered_servers["included"] == set()
+
+    def test_force_false_respects_opposing_set(self):
+        coder = SimpleNamespace(registered_servers={"included": set(), "excluded": {"github"}})
+
+        update_server_registration(coder, "GitHub", "include", force=False)
+
+        assert coder.registered_servers["included"] == set()
+        assert coder.registered_servers["excluded"] == {"github"}
+
+
+class TestIsServerGloballyExcludedCaseInsensitive:
+    """Global-exclusion checks match lowercase registered names."""
+
+    def test_included_server_is_not_globally_excluded(self):
+        coder = SimpleNamespace(registered_servers={"included": {"github"}, "excluded": set()})
+
+        with patch("cecli.commands.utils.helpers.iter_all_coders", return_value=[coder]):
+            assert is_server_globally_excluded(coder, "GitHub") is False
+
+    def test_excluded_server_is_globally_excluded(self):
+        coder = SimpleNamespace(registered_servers={"included": set(), "excluded": {"github"}})
+
+        with patch("cecli.commands.utils.helpers.iter_all_coders", return_value=[coder]):
+            assert is_server_globally_excluded(coder, "GITHUB") is True
+
+
+def _manager_with_servers():
+    """Manager with real servers named 'GitHub'/'Local' (normalized to lowercase)."""
+    github = McpServer({"name": "GitHub"})
+    local = McpServer({"name": "Local"})
+    manager = McpServerManager(servers=[github, local])
+    manager._server_tools = {
+        "github": [_tool("list_issues")],
+        "local": [_tool("read_file")],
+    }
+    manager._connected_servers = {github, local}
+    return manager
+
+
+class TestGetToolListExactMatchFiltering:
+    """Per-coder filtering uses exact match on lowercase names."""
+
+    def _coder(self, included=None, excluded=None):
+        manager = _manager_with_servers()
+        return SimpleNamespace(
+            mcp_tools=list(manager.all_tools.items()),
+            registered_servers={
+                "included": set(included or []),
+                "excluded": set(excluded or []),
+            },
+            registered_tools={"included": set(), "excluded": set()},
+        )
+
+    def test_include_list_keeps_only_matching_server(self):
+        coder = self._coder(included=["github"])
+
+        names = [t["function"]["name"] for t in Coder.get_tool_list(coder)]
+
+        assert names == ["github--list_issues"]
+
+    def test_empty_include_includes_all(self):
+        coder = self._coder()
+
+        names = [t["function"]["name"] for t in Coder.get_tool_list(coder)]
+
+        assert set(names) == {"github--list_issues", "local--read_file"}
+
+    def test_exclude_list_filters_by_lowercase(self):
+        coder = self._coder(excluded=["github"])
+
+        names = [t["function"]["name"] for t in Coder.get_tool_list(coder)]
+
+        assert names == ["local--read_file"]
+
+
+class TestGetServersContextExactMatchFiltering:
+    """Servers context block classifies servers using exact lowercase match."""
+
+    def _coder(self, included=None, excluded=None):
+        return SimpleNamespace(
+            use_enhanced_context=True,
+            io=MagicMock(),
+            mcp_manager=_manager_with_servers(),
+            registered_servers={
+                "included": set(included or []),
+                "excluded": set(excluded or []),
+            },
+        )
+
+    def test_include_list_marks_others_inactive(self):
+        coder = self._coder(included=["github"])
+
+        ctx = AgentCoder.get_servers_context(coder)
+
+        assert "Active (1):" in ctx
+        assert "- github" in ctx
+        assert "Inactive (Filtered) (1):" in ctx
+        assert "- local" in ctx
+
+    def test_empty_include_lists_all_active(self):
+        coder = self._coder()
+
+        ctx = AgentCoder.get_servers_context(coder)
+
+        assert "Active (2):" in ctx
+        assert "Inactive (Filtered)" not in ctx
+
+
+class TestLoadMcpCommandConversionLowercases:
+    """Empty include sets are converted to lowercase connected names + 'local'."""
+
+    @pytest.mark.asyncio
+    async def test_empty_include_converted_to_lowercase(self):
+        coder = MagicMock()
+        coder.io = MagicMock()
+        coder.edit_format = "agent"
+        coder.interrupt_event = MagicMock()
+        coder.interrupt_event.clear = MagicMock()
+        coder.registered_servers = {"included": set(), "excluded": set()}
+
+        github = MagicMock()
+        github.name = "GitHub"
+        github.config = {"enabled": True}
+        local = MagicMock()
+        local.name = "Local"
+        local.config = {}
+
+        coder.mcp_manager = MagicMock()
+        coder.mcp_manager.servers = [github, local]
+        coder.mcp_manager.connected_servers = [github, local]
+        coder.mcp_manager.get_server = MagicMock(return_value=github)
+        coder.mcp_manager.connect_server = AsyncMock(return_value=True)
+
+        async def _passthrough(coro, event):
+            return await coro, False
+
+        coder.coroutines = MagicMock()
+        coder.coroutines.interruptible = _passthrough
+
+        with patch("cecli.commands.load_mcp.iter_all_coders", return_value=[coder]):
+            with pytest.raises(SwitchCoderSignal):
+                await LoadMcpCommand.execute(coder.io, coder, "GitHub")
+
+        assert coder.registered_servers["included"] == {"github", "local"}
+
+
+class TestLocalServerConnectedUnderLowercaseKey:
+    """Connecting the Local server stores tools under the lowercase name."""
+
+    @pytest.mark.asyncio
+    async def test_connect_local_server_key_is_lowercase(self):
+        local = LocalServer({"name": "Local"})
+        manager = McpServerManager(servers=[local])
+
+        with patch("cecli.mcp.manager.get_local_tool_schemas", return_value=[_tool("x")]):
+            assert await manager.connect_server("Local") is True
+
+        assert "local" in manager._server_tools
+        assert "Local" not in manager._server_tools