Clean PR #694: drop .gitignore additions, map tool names via dicts

Revert the beads/dolt entries the PR added to .gitignore so the merge
touches code only.

Replace the per-call scan in responses.original_tool_name() with
module-level dicts that cache the original/sanitized MCP tool name
pairs. register_tool_names() fills them from coder.mcp_tools inside
get_tool_list(), so dispatching a tool call is now a dict lookup
instead of iterating every advertised tool. sanitize_tool_name() also
reuses its cache.

Author: dwash96

.gitignore

@@ -47,10 +47,4 @@ __pycache__/
 cecli/website/_site/*
 cecli/website/.sass-cache/*
 cecli/website/.docmd-*/*
-cecli/website/node_modules/*
-
-# Beads / Dolt files (added by bd init)
-.dolt/
-*.db
-.beads-credential-key
-.beads/proxieddb/
+cecli/website/node_modules/*

cecli/coders/base_coder.py

@@ -3412,7 +3412,7 @@ async def call_mcp_tool_from_session(self, session, tool_call):
 
         # Providers require a provider-safe tool name, so the name coming back
         # from the model may not be the name the MCP server advertises.
-        name = responses.original_tool_name(name, self.mcp_tools)
+        name = responses.original_tool_name(name)
 
         return await session.call_tool(name=name, arguments=arguments)
 
@@ -3503,6 +3503,7 @@ def mcp_tools(self, value):
 
     def get_tool_list(self):
         """Get a flattened list of all MCP tools with server prefixes, filtered by registered_servers."""
+        responses.register_tool_names(self.mcp_tools)
         tool_list = []
         if self.mcp_tools:
             for server_name, server_tools in self.mcp_tools:

cecli/helpers/responses.py

@@ -247,6 +247,10 @@ def extract_tools_from_pseudo_json(content: str) -> Optional[List[ChatCompletion
         return None
 
 
+_tool_name_to_sanitized: dict[str, str] = {}
+_sanitized_to_tool_name: dict[str, str] = {}
+
+
 def sanitize_tool_name(name: str) -> str:
     """Make a name acceptable in OpenAI-style ``tools[].function.name``.
 
@@ -255,22 +259,42 @@ def sanitize_tool_name(name: str) -> str:
     Idempotent, so it is also safe on an incoming tool call before the name is
     compared against, or mapped back to, the server's own name.
     """
-    return re.sub(r"[^A-Za-z0-9_-]", "_", name)[:64]
+    cached = _tool_name_to_sanitized.get(name)
 
+    if cached is not None:
+        return cached
 
-def original_tool_name(name: str, server_tools) -> str:
-    """Map a sanitized tool name back to the name the MCP server advertises.
+    sanitized = re.sub(r"[^A-Za-z0-9_-]", "_", name)[:64]
+    _tool_name_to_sanitized[name] = sanitized
+
+    return sanitized
 
-    ``server_tools`` is an iterable of ``(server_name, tools)`` pairs. Returns
-    ``name`` unchanged when nothing matches, so an unsanitized name still
-    reaches the server as-is.
+
+def register_tool_names(server_tools) -> None:
+    """Cache the original/sanitized MCP tool name pairs.
+
+    ``server_tools`` is an iterable of ``(server_name, tools)`` pairs, i.e. the
+    shape of ``coder.mcp_tools``. Registering when the tool list is built means
+    mapping a call back to the server's advertised name is a dict lookup rather
+    than a scan over every tool on every call.
     """
     for _server_name, tools in server_tools or []:
         for tool in tools:
-            candidate = nested.getter(tool, "function.name", "")
-            if candidate and sanitize_tool_name(candidate) == name:
-                return candidate
-    return name
+            original = nested.getter(tool, "function.name", "")
+
+            if not original:
+                continue
+
+            _sanitized_to_tool_name[sanitize_tool_name(original)] = original
+
+
+def original_tool_name(name: str) -> str:
+    """Map a sanitized tool name back to the name the MCP server advertises.
+
+    Returns ``name`` unchanged when nothing matches, so an unsanitized name
+    still reaches the server as-is.
+    """
+    return _sanitized_to_tool_name.get(name, name)
 
 
 def prefix_tool_name(server_name: str, tool_name: str) -> str:

tests/mcp/test_tool_name_sanitization.py

@@ -43,6 +43,19 @@ def test_honors_provider_length_limit(self):
         assert len(responses.sanitize_tool_name("a" * 200)) == 64
 
 
+class TestRegisteredToolNames:
+    def test_registered_name_maps_back(self):
+        responses.register_tool_names([("browser", [_tool("browser.persisted_session.list")])])
+
+        assert (
+            responses.original_tool_name("browser_persisted_session_list")
+            == "browser.persisted_session.list"
+        )
+
+    def test_unknown_name_is_unchanged(self):
+        assert responses.original_tool_name("never_registered") == "never_registered"
+
+
 class TestGetToolListSanitizesNames:
     def _coder(self, tools):
         return SimpleNamespace(
@@ -88,9 +101,15 @@ def test_sanitized_call_resolves_to_its_server(self):
 class TestCallToolMapsBackToAdvertisedName:
     """The name the model calls must reach the server unsanitized."""
 
+    def _coder(self):
+        coder = SimpleNamespace(mcp_tools=[("browser", [_tool("browser.fetch")])])
+        responses.register_tool_names(coder.mcp_tools)
+
+        return coder
+
     @pytest.mark.asyncio
     async def test_sanitized_name_is_mapped_back(self):
-        coder = SimpleNamespace(mcp_tools=[("browser", [_tool("browser.fetch")])])
+        coder = self._coder()
         session = MagicMock()
         session.call_tool = AsyncMock(return_value="ok")
 
@@ -100,7 +119,7 @@ async def test_sanitized_name_is_mapped_back(self):
 
     @pytest.mark.asyncio
     async def test_unsanitized_name_passes_through(self):
-        coder = SimpleNamespace(mcp_tools=[("browser", [_tool("browser.fetch")])])
+        coder = self._coder()
         session = MagicMock()
         session.call_tool = AsyncMock(return_value="ok")
 
@@ -110,7 +129,7 @@ async def test_unsanitized_name_passes_through(self):
 
     @pytest.mark.asyncio
     async def test_unknown_name_is_not_rewritten(self):
-        coder = SimpleNamespace(mcp_tools=[("browser", [_tool("browser.fetch")])])
+        coder = self._coder()
         session = MagicMock()
         session.call_tool = AsyncMock(return_value="ok")