V1.2.0

cecli/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "1.0.5.dev"
+__version__ = "1.2.0.dev"
 safe_version = __version__
 
 try:

cecli/coders/base_coder.py

@@ -38,7 +38,7 @@
 from cecli.commands import Commands, SwitchCoderSignal
 from cecli.decoding import safe_open
 from cecli.exceptions import LiteLLMExceptions
-from cecli.helpers import command_parser, coroutines, nested, responses
+from cecli.helpers import command_parser, command_queue, coroutines, nested, responses
 from cecli.helpers.conversation import ConversationService, MessageTag
 from cecli.helpers.file_system import FileSystemService
 from cecli.helpers.io_proxy import IOProxy
@@ -585,6 +585,15 @@ def __init__(
         self.commands = commands or Commands(self.io, self, args=args)
         self.commands.coder = self
 
+        # Prompt queue for CLI-33: in-memory FIFO queue for deferred prompt
+        # processing. The queue lives on the coder so primary agents and
+        # sub-agents each have their own independent queue, managed by
+        # cecli.helpers.command_queue.
+        self.prompt_queue = []
+        self._queue_counter = 0
+        self._queue_lock = threading.Lock()
+        self._processing_queue = False
+
         self.data_cache = {
             "repo": {"last_key": "", "read_only_count": None},
         }
@@ -1951,6 +1960,20 @@ async def run_one(self, user_message, preproc):
 
             await self.auto_save_session(force=True)
 
+        # Move to the next queued prompt (CLI-33) only after the current message
+        # has fully completed, so the queue drains within run_one() instead of
+        # being watched by the generation loops.
+        if self.prompt_queue and not self._processing_queue:
+            self._processing_queue = True
+            try:
+                item = command_queue.dequeue_prompt(self)
+            finally:
+                self._processing_queue = False
+
+            if item is not None:
+                self.io.tool_output(f"Processing queued prompt (id: {item['id']})...")
+                await self.run_one(item["text"], preproc)
+
         if not await HookIntegration.call_end_hooks(self):
             self.io.tool_warning("Execution stopped by end hook")
             return
@@ -3060,7 +3083,7 @@ async def _execute_local_tools(self, tool_calls):
 
     async def _execute_mcp_tools(self, server, tool_calls):
         """Execute MCP tools via LiteLLM."""
-        import httpx
+        from cecli.http import httpx
 
         tool_responses = []
         try:
@@ -3491,9 +3514,9 @@ async def add_assistant_reply_to_cur_messages(self):
         msg = response_dict["choices"][0]["message"]
 
         if self.partial_response_tool_calls:
-            msg["tool_calls"] = self.partial_response_tool_calls
+            msg["tool_calls"] = [_tool_call_to_dict(tc) for tc in self.partial_response_tool_calls]
         elif self.partial_response_function_call:
-            msg["function_call"] = self.partial_response_function_call
+            msg["function_call"] = _function_call_to_dict(self.partial_response_function_call)
 
         if "reasoning_content" not in msg:
             msg["reasoning_content"] = self.partial_response_reasoning_content
@@ -3611,7 +3634,7 @@ async def check_for_file_mentions(self, content):
             return prompts.added_files.format(fnames=", ".join(added_fnames))
 
     async def send(self, messages, model=None, functions=None, tools=None):
-        from litellm.types.utils import ModelResponse
+        ModelResponse = litellm.types.utils.ModelResponse
 
         self.interrupt_event.clear()
         self.got_reasoning_content = False
@@ -3745,7 +3768,7 @@ async def send(self, messages, model=None, functions=None, tools=None):
                     self.io.ai_output(json.dumps(args, indent=4))
 
     async def show_send_output(self, completion):
-        from litellm.types.utils import ModelResponse
+        ModelResponse = litellm.types.utils.ModelResponse
 
         if self.verbose:
             print(completion)
@@ -4008,6 +4031,15 @@ def consolidate_chunks(self):
                         for key, value in psf.items():
                             if isinstance(value, list):
                                 message_provider_specific_fields.setdefault(key, []).extend(value)
+                            elif (
+                                key in message_provider_specific_fields
+                                and isinstance(message_provider_specific_fields[key], dict)
+                                and isinstance(value, dict)
+                            ):
+                                # Merge dict-valued metadata (e.g. gemini per-call
+                                # function_call_signatures) so parallel tool calls
+                                # each keep their own signature across chunks.
+                                message_provider_specific_fields[key].update(value)
                             elif value is not None:
                                 message_provider_specific_fields[key] = value
             except (AttributeError, IndexError):
@@ -4101,7 +4133,8 @@ def _build_tool_calls_from_chunks(self):
         parallel call is preserved, correctly ordered, and keeps its
         provider-specific fields (e.g. thought signatures) attached.
         """
-        from litellm.types.utils import ChatCompletionMessageToolCall, Function
+        ChatCompletionMessageToolCall = litellm.types.utils.ChatCompletionMessageToolCall
+        Function = litellm.types.utils.Function
 
         tool_calls_dict = {}
 
@@ -4632,7 +4665,12 @@ async def apply_updates(self):
     def parse_partial_args(self):
         # dump(self.partial_response_function_call)
 
-        data = self.partial_response_function_call.get("arguments")
+        function_call = self.partial_response_function_call
+        if isinstance(function_call, dict):
+            data = function_call.get("arguments")
+        else:
+            data = getattr(function_call, "arguments", None)
+
         if not data:
             return
 
@@ -4910,3 +4948,25 @@ def format_command_with_prefix(self, command):
         else:
             # Append the command to the prefix with a space
             return f"{command_prefix} {command}"
+
+
+def _tool_call_to_dict(tc):
+    """Normalize a tool call (dict or litellm-shaped object) to a wire-format dict."""
+    if isinstance(tc, dict):
+        return tc
+
+    if hasattr(tc, "to_dict"):
+        return tc.to_dict()
+
+    return tc
+
+
+def _function_call_to_dict(function_call):
+    """Normalize a function call (dict or litellm-shaped Function) to a dict."""
+    if isinstance(function_call, dict):
+        return function_call
+
+    if hasattr(function_call, "to_dict"):
+        return function_call.to_dict()
+
+    return function_call

cecli/coders/copypaste_coder.py

@@ -259,11 +259,11 @@ def _safe_token_count(text):
             ],
             created=int(time.time()),
             model=model.name,
-            usage={
-                "prompt_tokens": prompt_tokens,
-                "completion_tokens": completion_tokens,
-                "total_tokens": total_tokens,
-            },
+            usage=litellm.Usage(
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                total_tokens=total_tokens,
+            ),
         )
 
         kwargs = dict(model=model.name, messages=messages, stream=False)

cecli/coders/editblock_func_coder.py

@@ -92,7 +92,11 @@ def render_incremental_response(self, final=False):
         return res
 
     async def _update_files(self):
-        name = self.partial_response_function_call.get("name")
+        function_call = self.partial_response_function_call
+        if isinstance(function_call, dict):
+            name = function_call.get("name")
+        else:
+            name = getattr(function_call, "name", None)
 
         if name and name != "replace_lines":
             raise ValueError(f'Unknown function_call name="{name}", use name="replace_lines"')

cecli/coders/wholefile_func_coder.py

@@ -113,7 +113,11 @@ def live_diffs(self, fname, content, final):
         return "\n".join(show_diff)
 
     async def _update_files(self):
-        name = self.partial_response_function_call.get("name")
+        function_call = self.partial_response_function_call
+        if isinstance(function_call, dict):
+            name = function_call.get("name")
+        else:
+            name = getattr(function_call, "name", None)
         if name and name != "write_file":
             raise ValueError(f'Unknown function_call name="{name}", use name="write_file"')
 

cecli/commands/__init__.py

@@ -40,6 +40,7 @@
 from .include_skill import IncludeSkillCommand
 from .lint import LintCommand
 from .list_mcp import ListMcpCommand
+from .list_queue import ListQueueCommand
 from .list_sessions import ListSessionsCommand
 from .list_skills import ListSkillsCommand
 from .load import LoadCommand
@@ -55,6 +56,7 @@
 from .models import ModelsCommand
 from .multiline_mode import MultilineModeCommand
 from .paste import PasteCommand
+from .queue import QueueCommand
 from .quit import QuitCommand
 from .read_only import ReadOnlyCommand
 from .read_only_stub import ReadOnlyStubCommand
@@ -63,6 +65,7 @@
 from .remove_hook import RemoveHookCommand
 from .remove_mcp import RemoveMcpCommand
 from .remove_memory import RemoveMemoryCommand
+from .remove_queue import RemoveQueueCommand
 from .remove_skill import RemoveSkillCommand
 from .report import ReportCommand
 from .reset import ResetCommand
@@ -133,6 +136,7 @@
 CommandRegistry.register(IncludeSkillCommand)
 CommandRegistry.register(LintCommand)
 CommandRegistry.register(ListMcpCommand)
+CommandRegistry.register(ListQueueCommand)
 CommandRegistry.register(ListSessionsCommand)
 CommandRegistry.register(ListSkillsCommand)
 CommandRegistry.register(LoadCommand)
@@ -148,13 +152,15 @@
 CommandRegistry.register(ModelsCommand)
 CommandRegistry.register(MultilineModeCommand)
 CommandRegistry.register(PasteCommand)
+CommandRegistry.register(QueueCommand)
 CommandRegistry.register(QuitCommand)
 CommandRegistry.register(ReadOnlyCommand)
 CommandRegistry.register(ReadOnlyStubCommand)
 CommandRegistry.register(ReasoningEffortCommand)
 CommandRegistry.register(RemoveHookCommand)
 CommandRegistry.register(RemoveMcpCommand)
 CommandRegistry.register(RemoveMemoryCommand)
+CommandRegistry.register(RemoveQueueCommand)
 CommandRegistry.register(RemoveSkillCommand)
 CommandRegistry.register(ReportCommand)
 CommandRegistry.register(ResetCommand)
@@ -237,6 +243,7 @@
     "parse_quoted_filenames",
     "PasteCommand",
     "quote_filename",
+    "QueueCommand",
     "QuitCommand",
     "ReadOnlyCommand",
     "ReadOnlyStubCommand",
@@ -245,6 +252,7 @@
     "RemoveHookCommand",
     "RemoveMcpCommand",
     "RemoveMemoryCommand",
+    "RemoveQueueCommand",
     "RemoveSkillCommand",
     "ReportCommand",
     "ResetCommand",

cecli/commands/core.py

@@ -89,6 +89,54 @@ def __init__(
         self.cmd_running_event.set()
         self.last_command_show_notification = True
 
+        # 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 _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.
@@ -183,7 +231,8 @@ async def execute(self, cmd_name, args, coder=None, **kwargs):
             return
 
         self.last_command_show_notification = command_class.show_completion_notification
-        self.cmd_running_event.clear()
+        if cmd_name not in self._MANAGEMENT_COMMANDS:
+            self.cmd_running_event.clear()
 
         try:
             kwargs.update(
@@ -226,6 +275,12 @@ def matching_commands(self, inp):
         return matching_commands, first_word, rest_inp
 
     async def run(self, inp, coder=None, **kwargs):
+        if inp.startswith("/"):
+            words = inp.strip().split()
+            cmd_name = words[0][1:]
+            rest_inp = inp[len(words[0]) :].strip()
+            return await self.execute(cmd_name, rest_inp, coder=coder, **kwargs)
+
         if inp.startswith("!!!"):
             return await self.execute(
                 "run", inp[3:], coder=coder, background=True, suppress_add=True