cecli-dev 0.100.6rc1__tar.gz → 0.100.6rc3__tar.gz

{cecli_dev-0.100.6rc1 → cecli_dev-0.100.6rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.6rc1
+Version: 0.100.6rc3
 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-0.100.6rc1 → cecli_dev-0.100.6rc3}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.6rc1'
-__version_tuple__ = version_tuple = (0, 100, 6, 'rc1')
+__version__ = version = '0.100.6rc3'
+__version_tuple__ = version_tuple = (0, 100, 6, 'rc3')
 
-__commit_id__ = commit_id = 'gd52e51e0f'
+__commit_id__ = commit_id = 'g4582a5088'

{cecli_dev-0.100.6rc1 → cecli_dev-0.100.6rc3}/cecli/args.py

@@ -276,7 +276,10 @@ def get_parser(default_config_files, git_root):
     group.add_argument(
         "--retries",
         metavar="RETRIES_JSON",
-        help="Specify LLM retry configuration as a JSON string",
+        help=(
+            'Specify LLM retry configuration as a JSON/YAML string (e.g., \'{"retry_on_empty": '
+            "true}')"
+        ),
         default=None,
     )
 

{cecli_dev-0.100.6rc1 → cecli_dev-0.100.6rc3}/cecli/args_formatter.py

@@ -132,6 +132,16 @@ class YamlHelpFormatter(argparse.HelpFormatter):
                 break
         switch = switch.lstrip("-")
 
+        if switch == "retries":
+            parts.append(f"## {action.help}")
+            parts.append("#retries:")
+            parts.append("#  retry-timeout: 60")
+            parts.append("#  retry-backoff-factor: 2.0")
+            parts.append("#  retry-on-unavailable: true")
+            parts.append("#  retry-on-empty: false")
+            parts.append("")
+            return "\n".join(parts)
+
         if isinstance(action, argparse._StoreTrueAction):
             default = False
         elif isinstance(action, argparse._StoreConstAction):

{cecli_dev-0.100.6rc1 → cecli_dev-0.100.6rc3}/cecli/coders/base_coder.py

@@ -46,6 +46,7 @@ from cecli.helpers.file_system import FileSystemService
 from cecli.helpers.io_proxy import IOProxy
 from cecli.helpers.observations.service import ObservationService
 from cecli.helpers.profiler import TokenProfiler
+from cecli.helpers.threading import ThreadSafeEvent
 from cecli.history import ChatSummary
 from cecli.hooks import HookIntegration
 from cecli.io import ConfirmGroup, InputOutput
@@ -91,6 +92,10 @@ class FinishReasonLength(Exception):
     pass
 
 
+class EmptyResponseError(Exception):
+    pass
+
+
 def wrap_fence(name):
     return f"<{name}>", f"</{name}>"
 
@@ -420,7 +425,7 @@ class Coder(metaclass=UsageMeta):
         # Each contains "included" and "excluded" sets that filter from the global singletons
         self.registered_tools = {"included": set(), "excluded": set()}
         self.registered_servers = {"included": set(), "excluded": set()}
-        self.interrupt_event = asyncio.Event()
+        self.interrupt_event = ThreadSafeEvent()
         self.uuid = str(generate_unique_id())
 
         if uuid:
@@ -1643,6 +1648,7 @@ class Coder(metaclass=UsageMeta):
 
     async def generate(self, user_message, preproc):
         await asyncio.sleep(0.1)
+        self.interrupt_event.clear()
 
         try:
             if self.enable_context_compaction:
@@ -2402,6 +2408,39 @@ class Coder(metaclass=UsageMeta):
                     async for chunk in self.send(messages, tools=self.get_tool_list()):
                         yield chunk
                     break
+                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)
+
+                    if not retry_on_empty:
+                        break
+
+                    retry_delay *= 2
+                    if retry_delay > RETRY_TIMEOUT:
+                        self.io.tool_error("Retry timeout exceeded on empty response.")
+                        break
+
+                    self.io.tool_output(f"Retrying in {retry_delay:.1f} seconds...")
+
+                    _res, interrupted_sleep = await coroutines.interruptible(
+                        asyncio.sleep(retry_delay), self.interrupt_event
+                    )
+                    if interrupted_sleep:
+                        interrupted = True
+                        break
+                    continue
                 except litellm_ex.exceptions_tuple() as err:
                     ex_info = litellm_ex.get_ex_info(err)
 
@@ -3252,6 +3291,7 @@ class Coder(metaclass=UsageMeta):
         self.interrupt_event.clear()
         self.got_reasoning_content = False
         self.ended_reasoning_content = False
+        self.empty_response = False
 
         self._streaming_buffer_length = 0
         self.io.reset_streaming_response()
@@ -3302,6 +3342,9 @@ class Coder(metaclass=UsageMeta):
             else:
                 await self.show_send_output(completion)
 
+            if self.empty_response:
+                raise EmptyResponseError
+
             response, func_err, content_err = self.consolidate_chunks()
 
             if response:
@@ -3382,7 +3425,8 @@ class Coder(metaclass=UsageMeta):
             and not len(self.partial_response_tool_calls)
             and not len(self.partial_response_reasoning_content)
         ):
-            self.io.tool_warning(self.empty_llm_tool_warning())
+            self.empty_response = True
+            return
 
         self.io.assistant_output(show_resp, pretty=self.show_pretty())
 
@@ -3539,7 +3583,8 @@ class Coder(metaclass=UsageMeta):
             return
 
         if not received_content and len(self.partial_response_tool_calls) == 0:
-            self.io.tool_warning(self.empty_llm_tool_warning())
+            self.empty_response = True
+            return
 
     def consolidate_chunks(self):
         if self.partial_response_consolidated:

{cecli_dev-0.100.6rc1 → cecli_dev-0.100.6rc3}/cecli/commands/core.py

@@ -1,4 +1,3 @@
-import asyncio
 import json
 import re
 import sys
@@ -7,6 +6,7 @@ from pathlib import Path
 from cecli.commands.utils.registry import CommandRegistry
 from cecli.helpers import nested, plugin_manager
 from cecli.helpers.file_searcher import handle_core_files
+from cecli.helpers.threading import ThreadSafeEvent
 from cecli.repo import ANY_GIT_ERROR
 
 
@@ -94,7 +94,7 @@ class Commands:
         self.custom_commands = nested.getter(customizations, "command-paths", [])
         self._load_custom_commands(self.custom_commands)
 
-        self.cmd_running_event = asyncio.Event()
+        self.cmd_running_event = ThreadSafeEvent()
         self.cmd_running_event.set()
         self.last_command_show_notification = True
 

{cecli_dev-0.100.6rc1 → cecli_dev-0.100.6rc3}/cecli/helpers/coroutines.py

@@ -1,5 +1,7 @@
 import asyncio
 
+from cecli.helpers.threading import ThreadSafeEvent
+
 
 async def interruptible_async_generator(async_generator, interrupt_event):
     """
@@ -57,7 +59,7 @@ async def interruptible(coroutine, interrupt_event):
         - If interrupted: (None, True)
     """
     if interrupt_event is None:
-        interrupt_event = asyncio.Event()
+        interrupt_event = ThreadSafeEvent()
 
     main_task = asyncio.create_task(coroutine)
     interrupt_task = asyncio.create_task(interrupt_event.wait())

{cecli_dev-0.100.6rc1 → cecli_dev-0.100.6rc3}/cecli/helpers/hashpos/hashpos.py

@@ -221,6 +221,6 @@ class HashPos:
         # If no pattern matches, raise error
         raise ValueError(
             f"Invalid HashPos format '{hashpos_str}'. "
-            r"Expected \"{hash_prefix}\" "
-            r"where hash_prefix is exactly 4 characters from the set [0-9a-zA-Z\~_@]."
+            r"Expected \"{content ID}\" "
+            r"where content ID is exactly 4 characters from the set [0-9a-zA-Z\~_@]."
         )

cecli_dev-0.100.6rc3/cecli/helpers/threading.py

@@ -0,0 +1,46 @@
+import asyncio
+import threading
+
+
+class ThreadSafeEvent:
+    def __init__(self):
+        self._async_event = asyncio.Event()
+        self._thread_event = threading.Event()
+
+    @staticmethod
+    def _get_loop():
+        """Dynamically resolve the running event loop (not cached)."""
+        try:
+            return asyncio.get_running_loop()
+        except RuntimeError:
+            return None
+
+    def set(self):
+        """Can be called from ANY thread or coroutine safely."""
+        # Unblock threads
+        self._thread_event.set()
+        # Unblock async loop
+        if loop := self._get_loop():
+            loop.call_soon_threadsafe(self._async_event.set)
+        else:
+            self._async_event.set()
+
+    def clear(self):
+        """Can be called from ANY thread or coroutine safely."""
+        self._thread_event.clear()
+        if loop := self._get_loop():
+            loop.call_soon_threadsafe(self._async_event.clear)
+        else:
+            self._async_event.clear()
+
+    def is_set(self):
+        """Thread-safe check."""
+        return self._thread_event.is_set()
+
+    def thread_wait(self, timeout=None):
+        """Call this from your background OS Thread."""
+        return self._thread_event.wait(timeout=timeout)
+
+    async def wait(self):
+        """Call this (with await) from your Async Coroutines."""
+        await self._async_event.wait()

{cecli_dev-0.100.6rc1 → cecli_dev-0.100.6rc3}/cecli/io.py

@@ -43,6 +43,7 @@ from rich.text import Text
 
 from cecli.commands import SwitchCoderSignal
 from cecli.helpers import coroutines
+from cecli.helpers.threading import ThreadSafeEvent
 from cecli.report import update_error_prefix
 
 from .dump import dump  # noqa: F401
@@ -395,7 +396,7 @@ class InputOutput:
         self.linear = False
 
         # State tracking for confirmation input
-        self.confirmation_in_progress_event = asyncio.Event()
+        self.confirmation_in_progress_event = ThreadSafeEvent()
         self.confirmation_in_progress_event.set()  # Initially set, meaning no confirmation in progress
         self.confirmation_acknowledgement = False
         self.confirmation_input_active = False

{cecli_dev-0.100.6rc1 → cecli_dev-0.100.6rc3}/cecli/linter.py

@@ -12,6 +12,7 @@ import oslex
 from cecli.dump import dump  # noqa: F401
 from cecli.helpers.grep_ast import TreeContext, filename_to_lang
 from cecli.helpers.grep_ast.tsl import get_parser  # noqa: E402
+from cecli.helpers.threading import ThreadSafeEvent
 from cecli.run_cmd import run_cmd_async, run_cmd_subprocess  # noqa: F401
 
 # tree_sitter is throwing a FutureWarning
@@ -22,7 +23,7 @@ class Linter:
     def __init__(self, encoding="utf-8", root=None, interrupt_event=None):
         self.encoding = encoding
         self.root = root
-        self.interrupt_event = interrupt_event or asyncio.Event()
+        self.interrupt_event = interrupt_event or ThreadSafeEvent()
 
         self.languages = dict(
             python=self.py_lint,

{cecli_dev-0.100.6rc1 → cecli_dev-0.100.6rc3}/cecli/mcp/server.py

@@ -42,6 +42,7 @@ class McpServer:
         self.io = io
         self.verbose = verbose
         self.session = None
+        self._connection_loop: asyncio.AbstractEventLoop | None = None
         self._cleanup_lock: asyncio.Lock = asyncio.Lock()
         self.exit_stack = AsyncExitStack()
 
@@ -59,10 +60,17 @@ class McpServer:
         Returns:
             ClientSession: The active session if mcp is not disabled
         """
+        current_loop = asyncio.get_running_loop()
         if self.session is not None:
+            # Event loop affinity check: streams from stdio_client() are bound
+            # to the loop that created them.  Reconnect if the loop changed.
+            if self._connection_loop is current_loop:
+                if self.verbose and self.io:
+                    self.io.tool_output(f"Using existing session for MCP server: {self.name}")
+                return self.session
             if self.verbose and self.io:
-                self.io.tool_output(f"Using existing session for MCP server: {self.name}")
-            return self.session
+                self.io.tool_output(f"Reconnecting MCP server {self.name} (event loop changed)")
+            await self.disconnect()
 
         if self.verbose and self.io:
             self.io.tool_output(f"Establishing new connection to MCP server: {self.name}")
@@ -87,6 +95,7 @@ class McpServer:
                 session = await self.exit_stack.enter_async_context(ClientSession(read, write))
                 await session.initialize()
                 self.session = session
+                self._connection_loop = current_loop
                 return session
         except Exception as e:
             logging.error(f"Error initializing server {self.name}: {e}")
@@ -193,10 +202,15 @@ class HttpBasedMcpServer(McpServer):
         raise NotImplementedError("Subclasses must implement _create_transport")
 
     async def connect(self):
+        current_loop = asyncio.get_running_loop()
         if self.session is not None:
+            if self._connection_loop is current_loop:
+                if self.verbose and self.io:
+                    self.io.tool_output(f"Using existing session for {self.name}")
+                return self.session
             if self.verbose and self.io:
-                self.io.tool_output(f"Using existing session for {self.name}")
-            return self.session
+                self.io.tool_output(f"Reconnecting {self.name} (event loop changed)")
+            await self.disconnect()
 
         if self.verbose and self.io:
             self.io.tool_output(f"Establishing new connection to {self.name}")
@@ -224,6 +238,7 @@ class HttpBasedMcpServer(McpServer):
             session = await self.exit_stack.enter_async_context(ClientSession(read, write))
             await session.initialize()
             self.session = session
+            self._connection_loop = current_loop
 
             if oauth_provider.context.oauth_metadata:
                 token_endpoint = oauth_provider._get_token_endpoint()
@@ -270,9 +285,13 @@ class SseServer(McpServer):
     """SSE (Server-Sent Events) MCP server using mcp.client.sse_client."""
 
     async def connect(self):
+        current_loop = asyncio.get_running_loop()
         if self.session is not None:
-            logging.info(f"Using existing session for SSE MCP server: {self.name}")
-            return self.session
+            if self._connection_loop is current_loop:
+                logging.info(f"Using existing session for SSE MCP server: {self.name}")
+                return self.session
+            logging.info(f"Reconnecting SSE MCP server {self.name} (event loop changed)")
+            await self.disconnect()
 
         logging.info(f"Establishing new connection to SSE MCP server: {self.name}")
         try:
@@ -285,6 +304,7 @@ class SseServer(McpServer):
             session = await self.exit_stack.enter_async_context(ClientSession(read, write))
             await session.initialize()
             self.session = session
+            self._connection_loop = current_loop
             return session
         except Exception as e:
             logging.error(f"Error initializing SSE server {self.name}: {e}")

{cecli_dev-0.100.6rc1 → cecli_dev-0.100.6rc3}/cecli/tools/_yield.py

@@ -1,6 +1,7 @@
 import asyncio
 import logging
 
+from cecli.helpers.threading import ThreadSafeEvent
 from cecli.tools.utils.base_tool import BaseTool
 from cecli.tools.utils.helpers import ToolError
 from cecli.tools.utils.output import color_markers, tool_footer, tool_header
@@ -65,7 +66,7 @@ class Tool(BaseTool):
                     # the interrupt event, avoiding nested asyncio.wait() calls.
                     interrupt_event = coder.interrupt_event
                     if interrupt_event is None:
-                        interrupt_event = asyncio.Event()
+                        interrupt_event = ThreadSafeEvent()
 
                     interrupt_task = asyncio.create_task(interrupt_event.wait())
                     pending = set(active_tasks) | {interrupt_task}