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

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

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.6.0rc3'
-__version_tuple__ = version_tuple = (1, 6, 0, 'rc3')
+__version__ = version = '1.6.0rc5'
+__version_tuple__ = version_tuple = (1, 6, 0, 'rc5')
 
-__commit_id__ = commit_id = 'g51e92ff65'
+__commit_id__ = commit_id = 'gca072134c'

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc5}/cecli/coders/agent_coder.py

@@ -939,7 +939,11 @@ class AgentCoder(Coder):
             lint_coro = self.lint_edited(edited, show_output=False)
             lint_errors, interrupted = await interruptible(lint_coro, self.interrupt_event)
             if interrupted:
-                raise KeyboardInterrupt("Interrupted during linting")
+                # Abort the turn with CancelledError, which the linear run loop
+                # handles by re-prompting for input. KeyboardInterrupt is a
+                # BaseException that would escape the worker's event loop and
+                # leave it unable to accept further prompts.
+                raise asyncio.CancelledError("Interrupted during linting")
 
             has_errors = False
 
@@ -1078,7 +1082,10 @@ class AgentCoder(Coder):
             sleep_coro = asyncio.sleep(command_timeout / 2)
             _res, interrupted = await interruptible(sleep_coro, self.interrupt_event)
             if interrupted:
-                raise KeyboardInterrupt("Interrupted while waiting for background commands")
+                # Use CancelledError (not KeyboardInterrupt) so the interrupt
+                # stays inside the worker loop and re-prompts, matching the
+                # lint interrupt path above.
+                raise asyncio.CancelledError("Interrupted while waiting for background commands")
             return True
 
         # Check for recently finished commands that need reflection

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc5}/cecli/coders/base_coder.py

@@ -1999,7 +1999,13 @@ class Coder(metaclass=UsageMeta):
             if self.commands.is_run_command(inp):
                 self.commands.cmd_running_event.clear()  # Command is running
 
-            return await self.commands.run(inp, coder=self, **run_kwargs)
+            try:
+                return await self.commands.run(inp, coder=self, **run_kwargs)
+            finally:
+                # Dispatch can return early (unknown/ambiguous command) or
+                # raise without ever running a command; the gate must still be
+                # reopened or the input/output loops park forever.
+                self.commands.cmd_running_event.set()
 
         await self.check_for_file_mentions(inp)
         inp = await self.check_for_urls(inp)

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc5}/cecli/commands/tokens.py

@@ -1,4 +1,5 @@
-from typing import List
+import json
+from typing import Any, Dict, List, Optional
 
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
@@ -9,6 +10,140 @@ class TokensCommand(BaseCommand):
     NORM_NAME = "tokens"
     DESCRIPTION = "Report on the number of tokens used by the current chat context"
 
+    @classmethod
+    def _extract_file_name(cls, msg: Dict[str, Any]) -> Optional[str]:
+        """Extract file name from a message dictionary."""
+        if not isinstance(msg, dict):
+            return None
+
+        # Check explicit image_file metadata first
+        fname = msg.get("image_file")
+        if fname:
+            return fname
+
+        content = msg.get("content")
+        if isinstance(content, str):
+            if content.startswith(("Original File Contents For", "Current File Contents For")):
+                lines = content.split("\n", 3)
+                if len(lines) > 1:
+                    return lines[1].strip()
+            elif content.startswith("Image file: "):
+                return content[len("Image file: ") :].strip()
+        elif isinstance(content, list):
+            for part in content:
+                if isinstance(part, dict):
+                    if part.get("image_file"):
+                        return part.get("image_file")
+                    text = part.get("text")
+                    if isinstance(text, str):
+                        if text.startswith(
+                            ("Original File Contents For", "Current File Contents For")
+                        ):
+                            lines = text.split("\n", 3)
+                            if len(lines) > 1:
+                                return lines[1].strip()
+                        elif text.startswith("Image file: "):
+                            return text[len("Image file: ") :].strip()
+                elif isinstance(part, str):
+                    if part.startswith(("Original File Contents For", "Current File Contents For")):
+                        lines = part.split("\n", 3)
+                        if len(lines) > 1:
+                            return lines[1].strip()
+                    elif part.startswith("Image file: "):
+                        return part[len("Image file: ") :].strip()
+
+        return None
+
+    @staticmethod
+    def binary_token_count(data_url: str, bytes_per_pixel: float = 1.0) -> int:
+        """Estimate OpenAI vision tokens for a base64 media data URL.
+
+        Assumes a 4:3 aspect ratio and 1 byte per pixel, which is a reasonable middle
+        ground for binary media when the true dimensions are unknown. The tile cost is
+        inflated by 1.33 and floored to keep the estimate on the pessimistic side.
+        """
+        import math
+
+        b64_data = data_url.split(",", 1)[1] if "," in data_url else data_url
+        padding = b64_data.count("=")
+        rough_bytes = max(0, (len(b64_data) * 3 // 4) - padding)
+        total_pixels = rough_bytes / bytes_per_pixel
+        height = math.sqrt((3 / 4) * total_pixels)
+        width = (4 / 3) * height
+
+        if max(width, height) > 2048:
+            scale = 2048 / max(width, height)
+            width *= scale
+            height *= scale
+
+        if min(width, height) > 768:
+            scale = 768 / min(width, height)
+            width *= scale
+            height *= scale
+
+        tiles = math.ceil(width / 512) * math.ceil(height / 512)
+
+        return math.floor((85 + (170 * tiles)) * 1.33)
+
+    @classmethod
+    def _extract_key_paths(cls, obj: Any, prefix: str = "") -> List[str]:
+        """Return the dot-separated paths of every leaf in a nested structure.
+
+        List indices are included as numeric segments, e.g. "0.image_url.url".
+        """
+        if isinstance(obj, dict):
+            items = obj.items()
+        elif isinstance(obj, list):
+            items = enumerate(obj)
+        else:
+            return [prefix] if prefix else []
+
+        paths = []
+        for key, value in items:
+            path = f"{prefix}.{key}" if prefix else str(key)
+            paths.extend(cls._extract_key_paths(value, path))
+
+        return paths
+
+    @classmethod
+    def _get_path_value(cls, obj: Any, path: str) -> Any:
+        """Resolve a dot-separated path produced by _extract_key_paths."""
+        for part in path.split("."):
+            obj = obj[int(part)] if isinstance(obj, list) else obj[part]
+
+        return obj
+
+    @classmethod
+    def _count_value_tokens(cls, coder, key: str, value: Any) -> int:
+        """Count tokens for an extracted value, estimating data URLs as binary media."""
+        if key == "url" and isinstance(value, str) and value.startswith("data:"):
+            return cls.binary_token_count(value)
+
+        return coder.main_model.token_count(value)
+
+    @classmethod
+    def _count_message_tokens(cls, coder, msg: Dict[str, Any]) -> int:
+        """Count tokens for a message, estimating binary data URLs instead of raw base64."""
+        content = msg.get("content") if isinstance(msg, dict) else None
+
+        if not isinstance(content, (list, dict)):
+            return coder.main_model.token_count([msg])
+
+        total = 0
+
+        for path in cls._extract_key_paths(content):
+            key = path.rsplit(".", 1)[-1]
+
+            if not key.isdigit() and key not in ("text", "content", "url"):
+                continue
+
+            value = cls._get_path_value(content, path)
+
+            if isinstance(value, str):
+                total += cls._count_value_tokens(coder, key, value)
+
+        return total
+
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
         res = []
@@ -55,6 +190,13 @@ class TokensCommand(BaseCommand):
 
         res.append((system_tokens, "system messages", ""))
 
+        # tool definitions
+        tool_list = coder.get_tool_list()
+
+        if tool_list:
+            tokens_tools = coder.main_model.token_count(json.dumps(tool_list))
+            res.append((tokens_tools, "tool schemas", ""))
+
         # chat history
         msgs_done = ConversationService.get_manager(coder).get_messages_dict(tag=MessageTag.DONE)
         msgs_cur = ConversationService.get_manager(coder).get_messages_dict(tag=MessageTag.CUR)
@@ -123,27 +265,10 @@ class TokensCommand(BaseCommand):
             # Group messages by file (each file has user and assistant messages)
             file_tokens = {}
             for msg in readonly_msgs:
-                # Extract file name from message content
-                content = msg.get("content", "")
-                if content.startswith("Original File Contents For"):
-                    # Extract file path from "File Contents {path}:"
-                    lines = content.split("\n", 3)
-                    if lines:
-                        file_line = lines[1]
-                        fname = file_line.strip()
-                        # Calculate tokens for this message
-                        tokens = coder.main_model.token_count([msg])
-                        if fname not in file_tokens:
-                            file_tokens[fname] = 0
-                        file_tokens[fname] += tokens
-                elif "image_file" in msg:
-                    # Handle image files
-                    fname = msg.get("image_file")
-                    if fname:
-                        tokens = coder.main_model.token_count([msg])
-                        if fname not in file_tokens:
-                            file_tokens[fname] = 0
-                        file_tokens[fname] += tokens
+                fname = cls._extract_file_name(msg)
+                if fname:
+                    tokens = cls._count_message_tokens(coder, msg)
+                    file_tokens[fname] = file_tokens.get(fname, 0) + tokens
 
             # Add to results
             for fname, tokens in file_tokens.items():
@@ -158,27 +283,10 @@ class TokensCommand(BaseCommand):
             msgs = ConversationService.get_manager(coder).get_messages_dict(tag=tag)
             if msgs:
                 for msg in msgs:
-                    # Extract file name from message content
-                    content = msg.get("content", "")
-                    if content.startswith("Original File Contents For"):
-                        # Extract file path from "File Contents {path}:"
-                        lines = content.split("\n", 3)
-                        if lines:
-                            file_line = lines[1]
-                            fname = file_line.strip()
-                            # Calculate tokens for this message
-                            tokens = coder.main_model.token_count([msg])
-                            if fname not in editable_file_tokens:
-                                editable_file_tokens[fname] = 0
-                            editable_file_tokens[fname] += tokens
-                    elif "image_file" in msg:
-                        # Handle image files
-                        fname = msg.get("image_file")
-                        if fname:
-                            tokens = coder.main_model.token_count([msg])
-                            if fname not in editable_file_tokens:
-                                editable_file_tokens[fname] = 0
-                            editable_file_tokens[fname] += tokens
+                    fname = cls._extract_file_name(msg)
+                    if fname:
+                        tokens = cls._count_message_tokens(coder, msg)
+                        editable_file_tokens[fname] = editable_file_tokens.get(fname, 0) + tokens
 
         # Add editable files to results
         for fname, tokens in editable_file_tokens.items():

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc5}/cecli/helpers/coroutines.py

@@ -9,16 +9,10 @@ logger = logging.getLogger(__name__)
 # Strong reference pool to protect fire-and-forget tasks from garbage collection
 background_tasks: set = set()
 
-
-def _handle_result(task: asyncio.Task) -> None:
-    """Callback to clean up references and capture exceptions safely."""
-    background_tasks.discard(task)
-    try:
-        task.result()
-    except asyncio.CancelledError:
-        pass
-    except Exception as e:
-        logger.error(f"Background task failed: {e}", exc_info=True)
+# Grace period granted to a cancelled task to unwind. Transports that defer or
+# swallow cancellation (AnyIO cancel scopes, shielded streams) would otherwise
+# block the interrupting coroutine forever.
+INTERRUPT_UNWIND_GRACE_SECONDS = 5.0
 
 
 def fire_and_forget(coro) -> asyncio.Task:
@@ -35,6 +29,7 @@ async def interruptible_async_generator(async_generator, interrupt_event):
     """
     gen = async_generator.__aiter__()
     interrupt_task = asyncio.create_task(interrupt_event.wait())
+    next_task = None
 
     try:
         while True:
@@ -44,11 +39,7 @@ async def interruptible_async_generator(async_generator, interrupt_event):
             )
 
             if interrupt_task in done:
-                next_task.cancel()
-                try:
-                    await next_task
-                except asyncio.CancelledError:
-                    pass
+                await cancel_and_abandon([next_task])
                 break
 
             if next_task in done:
@@ -57,11 +48,9 @@ async def interruptible_async_generator(async_generator, interrupt_event):
                 except StopAsyncIteration:
                     break
     finally:
-        interrupt_task.cancel()
-        try:
-            await interrupt_task
-        except asyncio.CancelledError:
-            pass
+        # Cancel whichever task is still pending if the generator is closed early
+        # (e.g. GeneratorExit at the wait or yield), not just the interrupt waiter.
+        await cancel_and_abandon([task for task in (next_task, interrupt_task) if task is not None])
 
 
 def is_active(task):
@@ -83,6 +72,10 @@ async def interruptible(coroutine, interrupt_event):
         A tuple of (result, interrupted).
         - If not interrupted: (coroutine_result, False)
         - If interrupted: (None, True)
+
+    A task that ignores cancellation is abandoned once the grace period
+    elapses (see cancel_and_abandon) so a wedged transport cannot block the
+    caller forever.
     """
     if interrupt_event is None:
         interrupt_event = ThreadSafeEvent()
@@ -90,25 +83,26 @@ async def interruptible(coroutine, interrupt_event):
     main_task = asyncio.create_task(coroutine)
     interrupt_task = asyncio.create_task(interrupt_event.wait())
 
-    done, pending = await asyncio.wait(
-        {main_task, interrupt_task},
-        return_when=asyncio.FIRST_COMPLETED,
-    )
+    try:
+        done, pending = await asyncio.wait(
+            {main_task, interrupt_task},
+            return_when=asyncio.FIRST_COMPLETED,
+        )
 
-    for task in pending:
-        task.cancel()
-        try:
-            await task
-        except asyncio.CancelledError:
-            pass  # Expected
+        await cancel_and_abandon(pending)
 
-    if interrupt_task in done:
-        return None, True
+        if interrupt_task in done:
+            return None, True
 
-    try:
-        return main_task.result(), False
-    except asyncio.CancelledError:
-        return None, True
+        try:
+            return main_task.result(), False
+        except asyncio.CancelledError:
+            return None, True
+    finally:
+        # When the caller is cancelled while waiting, neither branch above
+        # runs, so cancel any remaining tasks here instead of orphaning the
+        # inner coroutine (which would keep running detached).
+        await cancel_and_abandon([main_task, interrupt_task])
 
 
 def task_is_cancelling() -> bool:
@@ -133,3 +127,58 @@ def task_is_cancelling() -> bool:
 
     # Python 3.10 fallback: best-effort only (see docstring).
     return bool(getattr(task, "_must_cancel", False))
+
+
+def drain_task_results(tasks):
+    """Consume exceptions from finished tasks so they aren't reported as unretrieved."""
+    for task in tasks:
+        if task.cancelled():
+            continue
+
+        try:
+            exc = task.exception()
+        except (asyncio.CancelledError, asyncio.InvalidStateError):
+            continue
+
+        if exc is not None:
+            logger.warning(f"Task raised while unwinding after interrupt: {exc}")
+
+
+async def cancel_and_abandon(tasks, grace=INTERRUPT_UNWIND_GRACE_SECONDS):
+    """Cancel tasks and wait up to ``grace`` seconds for them to unwind.
+
+    Cancellation is cooperative, and some transports (AnyIO cancel scopes,
+    shielded streams) defer or swallow it. Waiting on them unconditionally
+    would block the caller forever, so anything still running after the grace
+    period is abandoned: it keeps a strong reference so it can finish on its
+    own without tripping the "Task was destroyed but it is pending" warning.
+    """
+    pending_tasks = [task for task in tasks if not task.done()]
+
+    if not pending_tasks:
+        return
+
+    for task in pending_tasks:
+        task.cancel()
+
+    done, still_running = await asyncio.wait(set(pending_tasks), timeout=grace)
+    drain_task_results(done)
+
+    for task in still_running:
+        logger.warning(
+            f"Task ignored cancellation after {grace}s; abandoning it. It may still be"
+            " running and could touch shared state later."
+        )
+        background_tasks.add(task)
+        task.add_done_callback(_handle_result)
+
+
+def _handle_result(task: asyncio.Task) -> None:
+    """Callback to clean up references and capture exceptions safely."""
+    background_tasks.discard(task)
+    try:
+        task.result()
+    except asyncio.CancelledError:
+        pass
+    except Exception as e:
+        logger.error(f"Background task failed: {e}", exc_info=True)

cecli_dev-1.6.0rc5/cecli/helpers/lock_detect.py

@@ -0,0 +1,137 @@
+import asyncio
+import logging
+import os
+import sys
+import threading
+import time
+import traceback
+
+from cecli.decoding import safe_open
+
+# Set up logging to catch asyncio framework logs
+logging.basicConfig(level=logging.INFO)
+logging.getLogger("asyncio").setLevel(logging.DEBUG)
+
+
+# Registered event loops whose asyncio tasks are included in each dump.
+# Task state is only read from the owning loop (see _dump_async_state), since
+# thread stacks alone cannot show coroutine/task state.
+_async_loops: dict = {}
+_async_state_providers: dict = {}
+
+
+def dump_stacks_to_file(filename=".cecli/logs/threads.log", interval=5, max_prints=10):
+    """Periodically writes stack traces to a file, resetting it after max_prints."""
+    print_count = 0
+
+    log_dir = os.path.dirname(filename)
+    if log_dir:
+        os.makedirs(log_dir, exist_ok=True)
+
+    while True:
+        time.sleep(interval)
+        try:
+            # Determine mode: "w" to overwrite/clear on the 11th print, "a" to append
+            mode = "w" if print_count >= max_prints else "a"
+
+            with safe_open(filename, mode) as f:
+                if mode == "w":
+                    f.write(f"--- Log reset automatically after {max_prints} prints ---\n")
+                    print_count = 0  # Reset the counter
+
+                timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+                f.write(
+                    f"\n=================== STACK TRACE DUMP ({timestamp}) ===================\n"
+                )
+
+                for thread_id, frame in sys._current_frames().items():
+                    thread_obj = threading._active.get(thread_id)
+                    thread_name = thread_obj.name if thread_obj else "Unknown Thread"
+
+                    f.write(f"\nThread Name: {thread_name} (ID: {thread_id})\n")
+                    f.write("-" * 40 + "\n")
+                    traceback.print_stack(frame, file=f)
+
+                f.write("=" * 70 + "\n")
+
+            for name in list(_async_loops.keys()):
+                _schedule_async_dump(name, filename)
+
+            print_count += 1  # Increment after a successful write
+
+        except Exception as e:
+            print(f"Error writing stack dump to file: {e}", file=sys.stderr)
+
+
+def register_async_loop(name, loop) -> None:
+    """Register an event loop to include asyncio task dumps for."""
+    _async_loops[name] = loop
+
+
+def register_async_state_provider(name, provider) -> None:
+    """Register a callable returning extra state text for a loop's dump."""
+    _async_state_providers[name] = provider
+
+
+def _format_async_tasks(loop, name) -> str:
+    """Return a readable dump of every task on ``loop`` (loop thread only)."""
+    lines = [f"\n------------------- ASYNCIO TASKS ({name}) -------------------\n"]
+
+    try:
+        tasks = asyncio.all_tasks(loop)
+    except Exception as e:
+        return f"<unable to read asyncio tasks: {e}>\n"
+
+    for task in tasks:
+        lines.append(f"\n[{task.get_name()}] done={task.done()} cancelled={task.cancelled()}\n")
+        lines.append(f"  {task.get_coro()!r}\n")
+
+        for frame in task.get_stack(limit=10):
+            lines.append("".join(traceback.format_stack(frame, limit=1)))
+
+    return "".join(lines)
+
+
+def _dump_async_state(name, filename) -> None:
+    """Append asyncio task/state info for one loop. Runs on the loop thread."""
+    loop = _async_loops.get(name)
+    if loop is None or loop.is_closed():
+        return
+
+    parts = []
+    provider = _async_state_providers.get(name)
+
+    if provider is not None:
+        try:
+            parts.append(provider())
+        except Exception as e:
+            parts.append(f"<state provider error: {e}>\n")
+
+    parts.append(_format_async_tasks(loop, name))
+
+    try:
+        with safe_open(filename, "a") as f:
+            f.write("".join(parts))
+    except Exception:
+        pass
+
+
+def _schedule_async_dump(name, filename) -> None:
+    """Schedule an async-state dump onto a registered loop, if it is running."""
+    loop = _async_loops.get(name)
+    if loop is None or loop.is_closed() or not loop.is_running():
+        return
+
+    try:
+        loop.call_soon_threadsafe(_dump_async_state, name, filename)
+    except RuntimeError:
+        pass
+
+
+# Start the monitor in a background daemon thread
+monitor_thread = threading.Thread(
+    target=dump_stacks_to_file,
+    args=(".cecli/logs/threads.log", 5, 10),  # Clears every 10 prints
+    daemon=True,
+)
+monitor_thread.start()

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc5}/cecli/mcp/manager.py

@@ -8,6 +8,9 @@ from cecli.tools.utils.registry import ToolRegistry
 # backstop, covering time the transport spends outside the SDK's read timeout.
 CONNECT_BACKSTOP_GRACE_SECONDS = 5
 
+# Servers whose failures are expected in normal operation and should not warn.
+QUIET_SERVER_NAMES = {"unnamed-server", "local"}
+
 
 class McpServerManager:
     """
@@ -387,14 +390,39 @@ class McpServerManager:
 
             return (server, success, True)
 
-        results = await asyncio.gather(*(_connect(server) for server in self._servers))
+        # return_exceptions=True keeps one bad server from aborting the batch and
+        # discarding every other server's result. A CancelledError that a
+        # transport raises for an ordinary connection failure lands in the
+        # results as a value; a genuine cancellation of this task still
+        # propagates through the gather itself, so it is not swallowed here.
+        outcomes = await asyncio.gather(
+            *(_connect(server) for server in self._servers), return_exceptions=True
+        )
+
+        results = []
+        for server, outcome in zip(self._servers, outcomes):
+            if isinstance(outcome, BaseException):
+                if isinstance(outcome, asyncio.CancelledError) and task_is_cancelling():
+                    # A genuine cancellation of this task must not be downgraded
+                    # to a failed server; let it propagate to the caller.
+                    raise outcome
+
+                # CancelledError discards its arguments, so fall back to the
+                # type name rather than reporting an empty cause.
+                cause = str(outcome) or type(outcome).__name__
+
+                if server.name.lower() not in QUIET_SERVER_NAMES:
+                    self._log_warning(f"MCP server {server.name} failed to initialize: {cause}")
+
+                # Reported here with its cause already, so flag it as
+                # not-attempted to keep the generic warning below from
+                # repeating the same failure.
+                results.append((server, False, False))
+            else:
+                results.append(outcome)
 
         for server, did_connect, attempted in results:
-            if (
-                attempted
-                and not did_connect
-                and server.name.lower() not in ["unnamed-server", "local"]
-            ):
+            if attempted and not did_connect and server.name.lower() not in QUIET_SERVER_NAMES:
                 self._log_warning(
                     f"MCP tool initialization failed after multiple retries: {server.name}"
                 )

{cecli_dev-1.6.0rc3 → cecli_dev-1.6.0rc5}/cecli/models.py

@@ -1487,7 +1487,7 @@ class Model(ModelSettings):
                 completion_coro = litellm.acompletion(**kwargs)
                 res, interrupted = await coroutines.interruptible(completion_coro, interrupt_event)
                 if interrupted:
-                    raise KeyboardInterrupt("Interrupted during acompletion")
+                    raise asyncio.CancelledError("Interrupted during acompletion")
 
                 return hash_object, res
             except litellm.ContextWindowExceededError as err:
@@ -1532,7 +1532,7 @@ class Model(ModelSettings):
                         asyncio.sleep(retry_delay), interrupt_event
                     )
                     if interrupted:
-                        raise KeyboardInterrupt("Interrupted during retry sleep")
+                        raise asyncio.CancelledError("Interrupted during retry sleep")
                 else:
                     await asyncio.sleep(retry_delay)
                 continue