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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.2.3rc3
+Version: 1.2.3rc5
 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.3rc5}/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.3rc5'
+__version_tuple__ = version_tuple = (1, 2, 3, 'rc5')
 
-__commit_id__ = commit_id = 'g3477cad89'
+__commit_id__ = commit_id = 'ge39a10435'

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc5}/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.3rc5}/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.3rc5}/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.3rc5}/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.3rc5}/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.3rc5}/cecli/helpers/llms/config.py

@@ -143,8 +143,8 @@ def resolve_model_config(model: str) -> Dict[str, Any]:
 
     # Effective cache flags for the domain adapters. Anthropic messages-API
     # models never cache "by default": prompt caching only happens when the
-    # request carries explicit ``cache_control`` breakpoints, so the messages
-    # domain injects them (agent.cache_control True + caches_by_default False).
+    # request asks for it, so the messages domain requests top-level automatic
+    # caching (agent.cache_control True + caches_by_default False).
     if family == "messages":
         agent_block["cache_control"] = True
         agent_block["caches_by_default"] = False

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc5}/cecli/helpers/llms/domains/messages.py

@@ -33,9 +33,6 @@ from ..utils import split_data_url, sse_json_lines, system_prompt
 
 DEFAULT_TIMEOUT = 120.0
 
-#: Anthropic allows at most 4 ``cache_control`` breakpoints per request.
-MAX_CACHE_BREAKPOINTS = 4
-
 
 def anthropic_payload(
     resolved: Dict[str, Any],
@@ -98,14 +95,13 @@ def anthropic_payload(
     extra_body.pop("thinking", None)
     payload.update(extra_body)
 
-    # Anthropic prompt caching is a byte-exact prefix match: it only happens
-    # when the request carries explicit ``cache_control`` breakpoints. The
-    # model config flags messages-API models ``cache_control`` True and
-    # ``caches_by_default`` False (see config.resolve_model_config), so the
-    # messages domain owns the marking here rather than the conversation
-    # manager.
+    # Anthropic prompt caching: request automatic caching via the top-level
+    # ``cache_control`` field. The model config flags messages-API models
+    # ``cache_control`` True and ``caches_by_default`` False (see
+    # config.resolve_model_config), so the messages domain requests it here
+    # rather than managing explicit per-block breakpoints.
     if agent_block.get("cache_control") and not agent_block.get("caches_by_default"):
-        _apply_anthropic_cache_control(payload)
+        payload["cache_control"] = {"type": "ephemeral"}
 
     return payload
 
@@ -627,140 +623,6 @@ def _anthropic_user_blocks(content: List[Dict[str, Any]]) -> List[Dict[str, Any]
     return blocks
 
 
-def _apply_anthropic_cache_control(payload: Dict[str, Any]) -> None:
-    """Attach ephemeral ``cache_control`` breakpoints to a copy of the stream.
-
-    Anthropic prompt caching is a byte-exact prefix match: a breakpoint on the
-    last content block of a message caches every token up to and including it.
-    Following the conversation manager's placement (``manager.py
-    _add_cache_control``), we mark the three stable boundaries of a multi-turn
-    exchange:
-
-    - the last system block at the start of the stream (which also covers the
-      tool definitions rendered before it), and
-    - the last content block of the two most recent non-tool user/assistant
-      turns.
-
-    The message stream is copied and only the key messages are replaced, so
-    caller-owned lists are never mutated. Anthropic allows at most
-    ``MAX_CACHE_BREAKPOINTS`` breakpoints per request, so the marking stops
-    early once that budget (including any caller-supplied markers) is
-    exhausted.
-    """
-    import copy
-
-    budget = MAX_CACHE_BREAKPOINTS - _count_cache_breakpoints(payload)
-
-    if budget <= 0:
-        return
-
-    system = payload.get("system")
-
-    if isinstance(system, str):
-        payload["system"] = [
-            {"type": "text", "text": system, "cache_control": {"type": "ephemeral"}}
-        ]
-        budget -= 1
-
-    elif isinstance(system, list) and system:
-        system = list(system)
-        last = system[-1]
-
-        if isinstance(last, dict):
-            last = copy.deepcopy(last)
-            system[-1] = last
-
-        if _mark_cache_breakpoint(last):
-            budget -= 1
-
-        payload["system"] = system
-
-    messages = payload.get("messages") or []
-    result = list(messages)
-    marked = 0
-
-    for i in range(len(result) - 1, -1, -1):
-        if marked >= 2 or budget <= 0:
-            break
-
-        msg = result[i]
-
-        if _is_tool_turn(msg):
-            continue
-
-        content = msg.get("content")
-
-        if isinstance(content, str):
-            msg = copy.deepcopy(msg)
-            msg["content"] = [
-                {"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}
-            ]
-            result[i] = msg
-            marked += 1
-            budget -= 1
-
-        elif isinstance(content, list) and content:
-            msg = copy.deepcopy(msg)
-            blocks = list(msg["content"])
-
-            if _mark_cache_breakpoint(blocks[-1]):
-                marked += 1
-                budget -= 1
-
-            msg["content"] = blocks
-            result[i] = msg
-
-    payload["messages"] = result
-
-
-def _count_cache_breakpoints(payload: Dict[str, Any]) -> int:
-    """Count existing ``cache_control`` markers in a payload (system + messages)."""
-    count = 0
-    system = payload.get("system")
-
-    if isinstance(system, list):
-        count += sum(isinstance(block, dict) and "cache_control" in block for block in system)
-
-    for tool in payload.get("tools") or []:
-        if isinstance(tool, dict) and "cache_control" in tool:
-            count += 1
-
-    for msg in payload.get("messages") or []:
-        content = msg.get("content")
-
-        if isinstance(content, list):
-            count += sum(isinstance(block, dict) and "cache_control" in block for block in content)
-
-    return count
-
-
-def _mark_cache_breakpoint(block: Any) -> bool:
-    """Add an ephemeral breakpoint to ``block`` unless it already has one."""
-    if not isinstance(block, dict) or "cache_control" in block:
-        return False
-
-    block["cache_control"] = {"type": "ephemeral"}
-
-    return True
-
-
-def _is_tool_turn(msg: Dict[str, Any]) -> bool:
-    """True when a wire message is a tool turn (transient content).
-
-    Matches the conversation manager's placement, which skips tool messages
-    and assistant tool-call turns when choosing cache breakpoints.
-    """
-    content = msg.get("content")
-
-    if not isinstance(content, list) or not content:
-        return False
-
-    return any(
-        isinstance(block, dict) and block.get("type") in ("tool_result", "tool_use")
-        for block in content
-    )
-
-
 def _coalesce_anthropic_messages(wire_messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     """Merge consecutive user turns into a single user message.
 

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc5}/cecli/helpers/model_config/agent.py

@@ -57,9 +57,9 @@ def derive_agent_config(provider: Optional[str], route: str, record: Optional[Di
         # assuming caching support.
         #
         # Anthropic messages-API models never cache "by default": prompt
-        # caching only happens when the request carries explicit
-        # ``cache_control`` breakpoints (injected by the llms messages
-        # domain), so keep ``caches_by_default`` off for them.
+        # caching only happens when the request asks for it (the llms
+        # messages domain requests top-level automatic caching), so keep
+        # ``caches_by_default`` off for them.
         "caches_by_default": (
             not uses_messages_api
             and (bool(record.get("cache_read_input_token_cost")) if record else True)

{cecli_dev-1.2.3rc3 → cecli_dev-1.2.3rc5}/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.3rc5}/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.3rc5}/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.3rc5}/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.3rc5}/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.3rc5}/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.3rc5}/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.3rc5}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.2.3rc3
+Version: 1.2.3rc5
 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.3rc5}/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.3rc5}/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.3rc5/cecli_dev.egg-info/scm_version.json

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