cecli-dev 1.6.1__tar.gz → 1.6.2rc2__tar.gz

{cecli_dev-1.6.1 → cecli_dev-1.6.2rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.6.1
+Version: 1.6.2rc2
 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.6.1 → cecli_dev-1.6.2rc2}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.6.1'
-__version_tuple__ = version_tuple = (1, 6, 1)
+__version__ = version = '1.6.2rc2'
+__version_tuple__ = version_tuple = (1, 6, 2, 'rc2')
 
-__commit_id__ = commit_id = 'ge49b18e26'
+__commit_id__ = commit_id = 'g699b98e21'

{cecli_dev-1.6.1 → cecli_dev-1.6.2rc2}/cecli/coders/base_coder.py

@@ -54,7 +54,6 @@ from cecli.io import ConfirmGroup, InputOutput
 from cecli.linter import Linter
 from cecli.llm import litellm
 from cecli.mcp import LocalServer
-from cecli.models import RETRY_TIMEOUT
 from cecli.reasoning_tags import (
     REASONING_TAG,
     format_reasoning_content,
@@ -2829,24 +2828,14 @@ class Coder(metaclass=UsageMeta):
                 except EmptyResponseError:
                     self.io.tool_warning(self.empty_llm_tool_warning())
 
-                    retry_on_empty = False
-                    retries_config = self.get_active_model().retries
-                    if isinstance(retries_config, str):
-                        try:
-                            retries_config = json.loads(retries_config)
-                        except json.JSONDecodeError:
-                            self.io.tool_warning(
-                                f"Could not parse retries config: {retries_config}"
-                            )
-                            retries_config = {}
-                    if isinstance(retries_config, dict):
-                        retry_on_empty = retries_config.get("retry_on_empty", False)
+                    retry_config = models.parse_retry_config(self.get_active_model().retries)
+                    retry_on_empty = retry_config["retry_on_empty"]
 
                     if not retry_on_empty:
                         break
 
-                    retry_delay *= 2
-                    if retry_delay > RETRY_TIMEOUT:
+                    retry_delay *= retry_config["retry_backoff_factor"]
+                    if retry_delay > retry_config["retry_timeout"]:
                         self.io.tool_error("Retry timeout exceeded on empty response.")
                         break
 
@@ -2866,10 +2855,15 @@ class Coder(metaclass=UsageMeta):
                         exhausted = True
                         break
 
+                    retry_config = models.parse_retry_config(self.get_active_model().retries)
+
                     should_retry = ex_info.retry
+                    if ex_info.name == "ServiceUnavailableError":
+                        should_retry = should_retry or retry_config["retry_on_unavailable"]
+
                     if should_retry:
-                        retry_delay *= 2
-                        if retry_delay > RETRY_TIMEOUT:
+                        retry_delay *= retry_config["retry_backoff_factor"]
+                        if retry_delay > retry_config["retry_timeout"]:
                             should_retry = False
 
                     if not should_retry:
@@ -3193,7 +3187,8 @@ class Coder(metaclass=UsageMeta):
                 tool_name_from_schema = nested.getter(tool, "function.name")
                 if (
                     tool_name_from_schema
-                    and tool_name_from_schema.lower() == unprefixed_tool_name.lower()
+                    and responses.sanitize_tool_name(tool_name_from_schema).lower()
+                    == responses.sanitize_tool_name(unprefixed_tool_name).lower()
                 ):
                     # Find the McpServer instance that will be used for communication
                     for server in self.mcp_manager:
@@ -3415,6 +3410,10 @@ class Coder(metaclass=UsageMeta):
         # with a "missing required parameter" error.
         arguments = responses.coerce_tool_structure(arguments)
 
+        # 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)
+
         return await session.call_tool(name=name, arguments=arguments)
 
     async def process_tool_calls(self, tool_call_response):
@@ -3504,6 +3503,7 @@ class Coder(metaclass=UsageMeta):
 
     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_dev-1.6.1 → cecli_dev-1.6.2rc2}/cecli/commands/core.py

@@ -92,57 +92,6 @@ class Commands:
         # Commands that should NOT trigger auto-processing of the queue
         self._MANAGEMENT_COMMANDS = {"queue", "list-queue", "remove-queue"}
 
-    # ── Queue Management Methods (CLI-33) ────────────────────────────── #
-    #
-    # The prompt queue itself lives on the coder (Coder.prompt_queue) and
-    # is managed by cecli.helpers.command_queue. These thin wrappers keep
-    # the /queue, /list-queue and /remove-queue command implementations
-    # stable while operating on the coder that owns this Commands
-    # instance, so each sub-agent's commands manage that sub-agent's own
-    # queue.
-
-    @property
-    def prompt_queue(self):
-        """Proxy to the owning coder's prompt queue."""
-        coder = self.coder
-        return coder.prompt_queue if coder is not None else []
-
-    def _insert_prompt(self, text: str, index: int) -> dict:
-        """Insert a prompt at the given index in the active coder's queue."""
-        from cecli.helpers import command_queue
-
-        return command_queue.insert_prompt(self._active_coder(), text, index)
-
-    def _enqueue_prompt(self, text: str) -> dict:
-        """Add a prompt to the owning coder's queue."""
-        from cecli.helpers import command_queue
-
-        return command_queue.enqueue_prompt(self.coder, text)
-
-    def _dequeue_prompt(self) -> dict | None:
-        """Remove and return the first item from the owning coder's queue."""
-        from cecli.helpers import command_queue
-
-        return command_queue.dequeue_prompt(self.coder)
-
-    def _get_queue_length(self) -> int:
-        """Return the current number of items in the owning coder's queue."""
-        from cecli.helpers import command_queue
-
-        return command_queue.get_queue_length(self.coder)
-
-    def _remove_from_queue(self, index: int) -> dict | None:
-        """Remove and return the item at the given index from the owning coder's queue."""
-        from cecli.helpers import command_queue
-
-        return command_queue.remove_from_queue(self.coder, index)
-
-    def _clear_queue(self) -> list:
-        """Remove all items from the owning coder's queue and return them."""
-        from cecli.helpers import command_queue
-
-        return command_queue.clear_queue(self.coder)
-
     def _load_custom_commands(self, custom_commands):
         """
         Load custom commands from plugin paths.

{cecli_dev-1.6.1 → cecli_dev-1.6.2rc2}/cecli/commands/insert_queue.py

@@ -4,6 +4,7 @@ from typing import List
 
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
+from cecli.helpers import command_queue
 
 
 class InsertQueueCommand(BaseCommand):
@@ -57,7 +58,7 @@ class InsertQueueCommand(BaseCommand):
 
         # Happy path: insert the prompt
         try:
-            item = coder.commands._insert_prompt(prompt_text, index)
+            item = command_queue.insert_prompt(coder, prompt_text, index)
             io.tool_output(f"Prompt inserted at position {index + 1} (id: {item['id']})")
             return f"Successfully executed {cls.NORM_NAME}."
         except ValueError as e:

{cecli_dev-1.6.1 → cecli_dev-1.6.2rc2}/cecli/commands/list_queue.py

@@ -5,6 +5,7 @@ from typing import List
 
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
+from cecli.helpers import command_queue
 
 
 class ListQueueCommand(BaseCommand):
@@ -30,7 +31,7 @@ class ListQueueCommand(BaseCommand):
                 io, cls.NORM_NAME, "", error="Command system not available. Cannot list queue."
             )
 
-        queue = coder.commands.prompt_queue
+        queue = command_queue.list_queue(coder)
 
         # Sad path: empty queue
         if not queue:

{cecli_dev-1.6.1 → cecli_dev-1.6.2rc2}/cecli/commands/queue.py

@@ -4,6 +4,7 @@ from typing import List
 
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
+from cecli.helpers import command_queue
 
 
 class QueueCommand(BaseCommand):
@@ -55,8 +56,8 @@ class QueueCommand(BaseCommand):
 
         # Happy path: enqueue the prompt
         try:
-            item = coder.commands._enqueue_prompt(prompt_text)
-            position = len(coder.commands.prompt_queue)
+            item = command_queue.enqueue_prompt(coder, prompt_text)
+            position = command_queue.get_queue_length(coder)
             io.tool_output(f"Prompt queued at position {position} (id: {item['id']})")
             return f"Successfully executed {cls.NORM_NAME}."
         except ValueError as e:

{cecli_dev-1.6.1 → cecli_dev-1.6.2rc2}/cecli/commands/remove_queue.py

@@ -4,6 +4,7 @@ from typing import List
 
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
+from cecli.helpers import command_queue
 
 
 class RemoveQueueCommand(BaseCommand):
@@ -33,14 +34,14 @@ class RemoveQueueCommand(BaseCommand):
             )
 
         # Sad path: empty queue
-        if coder.commands._get_queue_length() == 0:
+        if command_queue.get_queue_length(coder) == 0:
             return format_command_result(
                 io, cls.NORM_NAME, "", error="Queue is empty. Nothing to remove."
             )
 
         # Handle wildcard: clear entire queue
         if args and args.strip() == "*":
-            items = coder.commands._clear_queue()
+            items = command_queue.clear_queue(coder)
             count = len(items)
             io.tool_output(f"Removed all {count} queued prompt(s).")
             return f"Successfully executed {cls.NORM_NAME}."
@@ -57,9 +58,9 @@ class RemoveQueueCommand(BaseCommand):
                     error=f"Invalid index: '{args.strip()}'. Please provide a number or '*'.",
                 )
 
-            item = coder.commands._remove_from_queue(index)
+            item = command_queue.remove_from_queue(coder, index)
             if item is None:
-                queue_len = coder.commands._get_queue_length()
+                queue_len = command_queue.get_queue_length(coder)
                 return format_command_result(
                     io,
                     cls.NORM_NAME,
@@ -71,7 +72,7 @@ class RemoveQueueCommand(BaseCommand):
             return f"Successfully executed {cls.NORM_NAME}."
 
         # Interactive mode: no args provided
-        queue = coder.commands.prompt_queue
+        queue = command_queue.list_queue(coder)
         io.tool_output("Queued prompts:")
         for i, item in enumerate(queue, 1):
             text = item["text"][:80]
@@ -91,7 +92,7 @@ class RemoveQueueCommand(BaseCommand):
         if not coder.commands:
             return []
 
-        queue_len = coder.commands._get_queue_length()
+        queue_len = command_queue.get_queue_length(coder)
         completions = [str(i) for i in range(1, queue_len + 1)]
         completions.append("*")
         return completions

{cecli_dev-1.6.1 → cecli_dev-1.6.2rc2}/cecli/helpers/responses.py

@@ -247,6 +247,56 @@ 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``.
+
+    Providers enforce ``^[A-Za-z0-9_-]{1,64}$`` on the function name, which
+    rejects names an MCP server may legitimately advertise (``browser.fetch``).
+    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.
+    """
+    cached = _tool_name_to_sanitized.get(name)
+
+    if cached is not None:
+        return cached
+
+    sanitized = re.sub(r"[^A-Za-z0-9_-]", "_", name)[:64]
+    _tool_name_to_sanitized[name] = sanitized
+
+    return sanitized
+
+
+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:
+            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:
     """
     Prefix a tool name with the server name.
@@ -256,9 +306,9 @@ def prefix_tool_name(server_name: str, tool_name: str) -> str:
         tool_name: Original tool name
 
     Returns:
-        Prefixed tool name in format "{server_name}--{tool_name}"
+        Prefixed, provider-safe tool name in format "{server_name}--{tool_name}"
     """
-    return f"{server_name}--{tool_name}"
+    return sanitize_tool_name(f"{server_name}--{tool_name}")
 
 
 def unprefix_tool_name(prefixed_name: str) -> tuple[str, str]:

{cecli_dev-1.6.1 → cecli_dev-1.6.2rc2}/cecli/models.py

@@ -1452,21 +1452,10 @@ class Model(ModelSettings):
         litellm_ex = LiteLLMExceptions()
         retry_delay = 0.125
 
-        if self.retries:
-            retry_config = dict()
-            try:
-                retry_config = json.loads(self.retries)
-            except (json.JSONDecodeError, TypeError, ValueError):
-                retry_config = dict()
-                pass
-
-            self.retry_on_unavailable = bool(
-                nested.getter(retry_config, "retry-on-unavailable", True)
-            )
-            self.retry_backoff_factor = float(
-                nested.getter(retry_config, "retry-backoff-factor", 1.5)
-            )
-            self.retry_timeout = float(nested.getter(retry_config, "retry-timeout", 30))
+        retry_config = parse_retry_config(self.retries)
+        self.retry_on_unavailable = retry_config["retry_on_unavailable"]
+        self.retry_backoff_factor = retry_config["retry_backoff_factor"]
+        self.retry_timeout = retry_config["retry_timeout"]
 
         while True:
             try:
@@ -1557,6 +1546,11 @@ class Model(ModelSettings):
         temperature = None
         tools = None
 
+        retry_config = parse_retry_config(self.retries)
+        retry_backoff_factor = retry_config["retry_backoff_factor"]
+        retry_timeout = retry_config["retry_timeout"]
+        retry_on_unavailable = retry_config["retry_on_unavailable"]
+
         if self.verbose:
             dump(messages)
 
@@ -1607,14 +1601,17 @@ class Model(ModelSettings):
                 if ex_info.description:
                     print(ex_info.description)
                 should_retry = ex_info.retry
+                if ex_info.name == "ServiceUnavailableError":
+                    should_retry = should_retry or retry_on_unavailable
+
                 custom_retry_delay = self._extract_retry_delay(err)
                 if custom_retry_delay is not None:
                     retry_delay = custom_retry_delay
                     should_retry = True
                 elif should_retry:
-                    retry_delay *= 2
+                    retry_delay *= retry_backoff_factor
 
-                if retry_delay > RETRY_TIMEOUT:
+                if retry_delay > retry_timeout:
                     should_retry = False
 
                 if not should_retry:
@@ -1792,6 +1789,42 @@ class Model(ModelSettings):
         return provider
 
 
+def parse_retry_config(retries_input):
+    """
+    Parse and normalize retry configuration from a JSON string or dict.
+    Returns a unified dict with defaults:
+      retry_timeout: 30
+      retry_backoff_factor: 1.5
+      retry_on_unavailable: True
+      retry_on_empty: False
+    """
+    config = dict()
+    if isinstance(retries_input, str):
+        try:
+            config = json.loads(retries_input)
+        except (json.JSONDecodeError, TypeError, ValueError):
+            config = dict()
+    elif isinstance(retries_input, dict):
+        config = retries_input.copy()
+
+    # Helper to get either hyphenated or underscored key
+    def _get(key, default):
+        val = config.get(key)
+        if val is not None:
+            return val
+        val = config.get(key.replace("_", "-"))
+        if val is not None:
+            return val
+        return default
+
+    return {
+        "retry_timeout": float(_get("retry_timeout", 30)),
+        "retry_backoff_factor": float(_get("retry_backoff_factor", 1.5)),
+        "retry_on_unavailable": bool(_get("retry_on_unavailable", True)),
+        "retry_on_empty": bool(_get("retry_on_empty", False)),
+    }
+
+
 def register_models(model_settings_fnames):
     files_loaded = []
     for model_settings_fname in model_settings_fnames:

{cecli_dev-1.6.1 → cecli_dev-1.6.2rc2}/cecli/resources/providers.json

@@ -322,6 +322,16 @@
     ],
     "display_name": "ollama"
   },
+  "ollama_chat": {
+    "api_base": "http://localhost:11434/v1",
+    "api_key_env": [
+      "OLLAMA_API_KEY"
+    ],
+    "base_url_env": [
+      "OLLAMA_API_BASE"
+    ],
+    "display_name": "ollama_chat"
+  },  
   "opencode-go": {
     "api_base": "https://opencode.ai/zen/go/v1",
     "api_key_env": [