cecli-dev 0.100.4rc3__tar.gz → 0.100.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.4rc3
+Version: 0.100.6
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -53,6 +53,7 @@ Requires-Dist: truststore
 Requires-Dist: xxhash>=3.6.0
 Requires-Dist: py-cymbal>=0.1.24
 Requires-Dist: cryptography>=42.0.0
+Requires-Dist: json-repair>=0.60.1
 Requires-Dist: marisa-trie>=1.0
 Requires-Dist: rapidfuzz>=3.0
 Requires-Dist: ngram>=4.0.3

{cecli_dev-0.100.4rc3 → cecli_dev-0.100.6}/cecli/__init__.py

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

{cecli_dev-0.100.4rc3 → cecli_dev-0.100.6}/cecli/_version.py

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

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

@@ -121,6 +121,7 @@ def get_parser(default_config_files, git_root):
     )
     group.add_argument(
         "--model-overrides",
+        "--model-settings",
         metavar="MODEL_OVERRIDES_JSON",
         help=(
             'Specify model tag overrides directly as JSON/YAML string (e.g., \'{"gpt-4o": {"high":'
@@ -275,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.4rc3 → cecli_dev-0.100.6}/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.4rc3 → cecli_dev-0.100.6}/cecli/coders/agent_coder.py

@@ -91,6 +91,7 @@ class AgentCoder(Coder):
         self.allowed_context_blocks = set()
         self.context_block_tokens = {}
         self.context_blocks_cache = {}
+        self.current_tasks = []
         self.hot_reload_enabled = False
         self.tokens_calculated = False
         self.skip_cli_confirmations = False
@@ -152,6 +153,7 @@ class AgentCoder(Coder):
             config, "skip_cli_confirmations", nested.getter(config, "yolo", [])
         )
         config["command_timeout"] = nested.getter(config, "command_timeout", 30)
+        config["allowed_commands"] = nested.getter(config, "allowed_commands", [])
         config["hot_reload"] = nested.getter(config, "hot_reload", False)
         config["allow_nested_delegation"] = nested.getter(config, "allow_nested_delegation", False)
 
@@ -160,7 +162,9 @@ class AgentCoder(Coder):
             config, ["tools_includelist", "tools_whitelist"], []
         )
         config["tools_excludelist"] = nested.getter(
-            config, ["tools_excludelist", "tools_blacklist"], []
+            config,
+            ["tools_excludelist", "tools_blacklist"],
+            ["gitbranch", "gitdiff", "gitlog", "gitremote", "gitshow", "gitstatus"],
         )
 
         config["servers_includelist"] = nested.getter(
@@ -174,7 +178,7 @@ class AgentCoder(Coder):
                 config,
                 "include_context_blocks",
                 {
-                    "context_summary",
+                    # "context_summary",
                     # "directory_structure",
                     "environment_info",
                     # "git_status",
@@ -239,20 +243,6 @@ class AgentCoder(Coder):
         if self.loaded_custom_tools:
             self.io.tool_output(f"Loaded custom tools: {', '.join(self.loaded_custom_tools)}")
 
-        skills = self.skills_manager.find_skills()
-        if skills:
-            skills_list = []
-            for skill in skills:
-                skills_list.append(skill.name)
-            joined_skills = ", ".join(skills_list)
-            self.io.tool_output(f"Available Skills: {joined_skills}")
-
-        registry = AgentService.get_registry()
-        if registry:
-            names = sorted(registry.keys())
-            joined_names = ", ".join(names)
-            self.io.tool_output(f"Available Subagents: {joined_names}")
-
     def get_local_tool_schemas(self):
         """Returns the JSON schemas for all local tools using the tool registry."""
         schemas = []
@@ -625,7 +615,7 @@ class AgentCoder(Coder):
                 percentage = total_tokens / max_input_tokens * 100
                 result += f" ({percentage:.1f}% of limit)"
                 if percentage > 80:
-                    result += "\n\n⚠️ **Context is getting full!**\n"
+                    result += "\n\n⚠ **Context is getting full!**\n"
                     result += "- Remove non-essential files via the `ContextManager` tool.\n"
                     result += "- Keep only essential files in context for best performance"
             result += "\n</context>"
@@ -822,6 +812,9 @@ class AgentCoder(Coder):
                     "# Fix any linting errors below, if possible and then continue with your task.",
                     1,
                 )
+                ConversationService.get_manager(self).remove_message_by_hash_key(
+                    ("lint_errors", "agent")
+                )
                 ConversationService.get_manager(self).add_message(
                     message_dict=dict(role="user", content=lint_errors),
                     tag=MessageTag.CUR,
@@ -1115,7 +1108,7 @@ class AgentCoder(Coder):
             context_parts.append("## File Editing Tools Disabled")
             context_parts.append(
                 "File editing tools are currently disabled. Use `ReadRange` to determine the"
-                " current content hash prefixes needed to perform an edit and activate them when"
+                " current content ID prefixes needed to perform an edit and activate them when"
                 " you are ready to edit a file."
             )
 
@@ -1279,16 +1272,20 @@ class AgentCoder(Coder):
         abs_path = self.abs_root_path(file_path)
         rel_path = self.get_rel_fname(abs_path)
         if not os.path.isfile(abs_path):
-            self.io.tool_output(f"⚠️ File '{file_path}' not found")
+            self.io.tool_output(f"⚠ File '{file_path}' not found", type="tool-result")
             return "File not found"
         if abs_path in self.abs_fnames:
             if explicit:
-                self.io.tool_output(f"📎 File '{file_path}' already in context as editable")
+                self.io.tool_output(
+                    f"🗀  File '{file_path}' already in context as editable", type="tool-result"
+                )
                 return "File already in context as editable"
             return "File already in context as editable"
         if abs_path in self.abs_read_only_fnames:
             if explicit:
-                self.io.tool_output(f"📎 File '{file_path}' already in context as read-only")
+                self.io.tool_output(
+                    f"🗀  File '{file_path}' already in context as read-only", type="tool-result"
+                )
                 return "File already in context as read-only"
             return "File already in context as read-only"
         try:
@@ -1299,13 +1296,18 @@ class AgentCoder(Coder):
                 file_tokens = self.get_active_model().token_count(content)
                 if file_tokens > self.large_file_token_threshold:
                     self.io.tool_output(
-                        f"⚠️ '{file_path}' is very large ({file_tokens} tokens). Use"
-                        " /context-management to toggle truncation off if needed."
+                        (
+                            f"⚠ '{file_path}' is very large ({file_tokens} tokens). Use"
+                            " /context-management to toggle truncation off if needed."
+                        ),
+                        type="tool-result",
                     )
             self.abs_read_only_fnames.add(abs_path)
             self.files_added_in_exploration.add(rel_path)
             if explicit:
-                self.io.tool_output(f"📎 Viewed '{file_path}' (added to context as read-only)")
+                self.io.tool_output(
+                    f"🗀  Viewed '{file_path}' (added to context as read-only)", type="tool-result"
+                )
                 return "Viewed file (added to context as read-only)"
             else:
                 return "Added file to context as read-only"
@@ -1432,10 +1434,11 @@ Todo list does not exist. Please update it with the `UpdateTodoList` tool.</cont
             content = self.io.read_text(abs_path)
             if content is None or not content.strip():
                 return None
+
+            current_tasks = "\n".join(self.current_tasks)
             result = '<context name="todo_list" from="agent">\n'
-            result += "## Current Todo List\n\n"
-            result += "Below is the current todo list managed via the `UpdateTodoList` tool:\n\n"
-            result += f"```\n{content}\n```\n"
+            result += "## Current Active Tasks\n\n"
+            result += f"```{current_tasks}```\n"
             result += "</context>"
             return result
         except Exception as e:

{cecli_dev-0.100.4rc3 → cecli_dev-0.100.6}/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,8 +425,9 @@ 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())
+        self.reflected_message = None
 
         if uuid:
             self.uuid = str(uuid)
@@ -460,9 +466,7 @@ class Coder(metaclass=UsageMeta):
 
         self.context_compaction_max_tokens = context_compaction_max_tokens
         self.context_compaction_summary_tokens = context_compaction_summary_tokens
-        self.max_reflections = (
-            3 if self.edit_format == "agent" else nested.getter(self.args, "max_reflections", 3)
-        )
+        self.max_reflections = nested.getter(self.args, "max_reflections", 3)
 
         if not fnames:
             fnames = []
@@ -775,91 +779,118 @@ class Coder(metaclass=UsageMeta):
         """Get CUR messages from ConversationManager."""
         return ConversationService.get_manager(self).get_messages_dict(MessageTag.CUR)
 
+    @staticmethod
+    def _strip_provider(model_name: str) -> str:
+        """Remove provider prefix from model name (e.g., 'openai/gpt-4' -> 'gpt-4')."""
+        if "/" in model_name:
+            return model_name.split("/", 1)[1]
+        return model_name
+
     def get_announcements(self):
-        lines = []
-        lines.append(f"cecli v{__version__}")
+        sections = {}
 
-        # Model
+        # --- MODELS ---
         main_model = self.main_model
-        weak_model = main_model.weak_model
+
+        models_items = [f"{self._strip_provider(main_model.name)} (main)"]
         agent_model = main_model.agent_model
+        weak_model = main_model.weak_model
 
-        if weak_model is not main_model:
-            prefix = "Main model"
-        else:
-            prefix = "Model"
+        if agent_model and agent_model.name != main_model.name:
+            models_items.append(f"{self._strip_provider(agent_model.name)} (agent)")
+
+        if weak_model and weak_model.name != main_model.name:
+            models_items.append(f"{self._strip_provider(weak_model.name)} (weak)")
+        if self.edit_format == "architect":
+            models_items.append(f"{self._strip_provider(main_model.editor_model.name)} (editor)")
+
+        sections["Models"] = {"items": models_items}
+
+        # --- SETTINGS ---
+        settings_items = []
 
-        output = f"{prefix}: {main_model.name} with {self.edit_format} edit format"
+        # Edit format
+        settings_items.append(f"{self.edit_format} (edit format)")
 
-        # Check for thinking token budget
+        # Thinking tokens
         thinking_tokens = main_model.get_thinking_tokens()
         if thinking_tokens:
-            output += f", {thinking_tokens} think tokens"
+            settings_items.append(f"{thinking_tokens} think tokens")
 
-        # Check for reasoning effort
+        # Reasoning effort
         reasoning_effort = main_model.get_reasoning_effort()
         if reasoning_effort:
-            output += f", reasoning {reasoning_effort}"
+            settings_items.append(f"reasoning {reasoning_effort}")
 
+        # Prompt cache
         if self.add_cache_headers or main_model.caches_by_default:
-            output += ", prompt cache"
-        if main_model.info.get("supports_assistant_prefill"):
-            output += ", infinite output"
-        if self.copy_paste_mode:
-            output += ", copy/paste mode"
+            settings_items.append("prompt cache")
 
-        lines.append(output)
+        # Infinite output
+        if main_model.info.get("supports_assistant_prefill"):
+            settings_items.append("infinite output")
 
-        if self.edit_format == "architect":
-            output = (
-                f"Editor model: {main_model.editor_model.name} with"
-                f" {main_model.editor_edit_format} edit format"
-            )
-            lines.append(output)
+        # Copy/paste mode
+        if self.copy_paste_mode:
+            settings_items.append("copy/paste mode")
 
-        if weak_model is not main_model:
-            output = f"Weak model: {weak_model.name}"
-            lines.append(output)
+        if settings_items:
+            sections["Settings"] = {"items": settings_items}
 
-        if agent_model is not main_model:
-            output = f"Agent model: {agent_model.name}"
-            lines.append(output)
+        # --- ENVIRONMENT ---
+        env_items = []
+        repo_map_tokens = None  # Track for later warning check
 
-        # Repo
         if self.repo:
             rel_repo_dir = self.repo.get_rel_repo_dir()
             num_files = len(self.repo.get_tracked_files())
-
-            lines.append(f"Git repo: {rel_repo_dir} with {num_files:,} files")
+            env_items.append(f"{rel_repo_dir} ({num_files:,} files)")
             if num_files > 1000:
-                lines.append(
+                env_items.append(
                     "Warning: For large repos, consider using --subtree-only and .cecli_ignore"
                 )
-                lines.append(f"See: {urls.large_repos}")
+                env_items.append(f"See: {urls.large_repos}")
         else:
-            lines.append("Git repo: none")
+            env_items.append("no git repo")
 
-        # Repo-map
         if self.repo_map:
             map_tokens = self.repo_map.max_map_tokens
             if map_tokens > 0:
                 refresh = self.repo_map.refresh
-                lines.append(f"Repo-map: using {map_tokens} tokens, {refresh} refresh")
-                max_map_tokens = self.get_active_model().get_repo_map_tokens() * 2
-                if map_tokens > max_map_tokens:
-                    lines.append(
-                        f"Warning: map-tokens > {max_map_tokens} is not recommended. Too much"
-                        " irrelevant code can confuse LLMs."
-                    )
+                env_items.append(f"map ({map_tokens} tokens, {refresh} refresh)")
+                repo_map_tokens = map_tokens
             else:
-                lines.append("Repo-map: disabled because map_tokens == 0")
+                env_items.append("repo-map disabled")
         else:
-            lines.append("Repo-map: disabled")
+            env_items.append("repo-map disabled")
 
+        sections["Environment"] = {"items": env_items}
+        # --- CAPABILITIES ---
+        capabilities = {}
+
+        # Sub-agents
+        try:
+            from cecli.helpers.agents.service import AgentService
+
+            registry = AgentService.get_registry()
+            if registry:
+                capabilities["Subagents"] = sorted(registry.keys())
+        except Exception:
+            pass
+
+        # Skills
+        if hasattr(self, "skills_manager") and self.skills_manager:
+            try:
+                skills = self.skills_manager.find_skills()
+                if skills:
+                    capabilities["Skills"] = [s.name for s in skills]
+            except Exception:
+                pass
+
+        # MCP Servers
         if self.mcp_tools:
             mcp_servers = []
             for server_name, server_tools in self.mcp_tools:
-                # Filter servers per instance configuration
                 if (
                     self.registered_servers["included"]
                     and server_name not in self.registered_servers["included"]
@@ -868,17 +899,49 @@ class Coder(metaclass=UsageMeta):
                 if server_name in self.registered_servers["excluded"]:
                     continue
                 mcp_servers.append(server_name)
-
             if mcp_servers:
-                lines.append(f"MCP servers configured: {', '.join(mcp_servers)}")
+                capabilities["Servers"] = mcp_servers
+
+        if capabilities:
+            # sections["Extensions"] = {"subsections": capabilities}
+            sections["Environment"]["subsections"] = capabilities
 
+        # --- RENDER ---
+        lines = []
+
+        # Version line (CLI only; TUI has its own banner)
+        if not self.args.tui:
+            lines.append(f"cecli v{__version__}")
+
+        for name, section in sections.items():
+            if "items" in section:
+                lines.append(f"{name:15s}" + " • ".join(section["items"]))
+            if "subsections" in section:
+                last_key = next(reversed(section["subsections"]))
+                # lines.append(name)
+                for sub_name, sub_items in section["subsections"].items():
+                    connector = "└─" if sub_name == last_key else "├─"
+                    lines.append(f" {connector} {sub_name:10} {' • '.join(sub_items)}")
+
+        # Repo-map max_tokens warning
+        if repo_map_tokens is not None:
+            max_map_tokens = self.get_active_model().get_repo_map_tokens() * 2
+            if repo_map_tokens > max_map_tokens:
+                lines.append(
+                    f"Warning: map-tokens > {max_map_tokens} is not recommended. Too much"
+                    " irrelevant code can confuse LLMs."
+                )
+
+        # Read-only stubs
         for fname in self.abs_read_only_stubs_fnames:
             rel_fname = self.get_rel_fname(fname)
             lines.append(f"Added {rel_fname} to the chat (read-only stub).")
 
+        # Restored conversation
         if ConversationService.get_manager(self).get_messages_dict(MessageTag.DONE):
             lines.append("Restored previous conversation history.")
 
+        # Multiline mode
         if self.io.multiline_mode and not self.args.tui:
             lines.append("Multiline mode: Enabled. Enter inserts newline, Alt-Enter submits text")
 
@@ -1045,7 +1108,7 @@ class Coder(metaclass=UsageMeta):
 
                             # Add message about showing definitions instead of full content
                             # self.io.tool_output(
-                            #    f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
+                            #    f"⚠ '{relative_fname}' is very large ({file_tokens} tokens). "
                             #    "Use /context-management to toggle truncation off if needed."
                             # )
 
@@ -1113,7 +1176,7 @@ class Coder(metaclass=UsageMeta):
 
                         # Add message about showing definitions instead of full content
                         # self.io.tool_output(
-                        #    f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
+                        #    f"⚠ '{relative_fname}' is very large ({file_tokens} tokens). "
                         #    "Use /context-management to toggle truncation off if needed."
                         # )
 
@@ -1645,6 +1708,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:
@@ -2404,6 +2468,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)
 
@@ -2464,7 +2561,9 @@ class Coder(metaclass=UsageMeta):
                     return
         finally:
             if self.mdstream:
-                content_to_show = self.live_incremental_response(True)
+                content_to_show = (
+                    "" if self.tui and self.tui() else self.live_incremental_response(True)
+                )
                 self.stream_wrapper(content_to_show, final=True)
             self.mdstream = None
 
@@ -3254,6 +3353,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()
@@ -3304,6 +3404,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:
@@ -3384,7 +3487,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())
 
@@ -3482,24 +3586,13 @@ class Coder(metaclass=UsageMeta):
                         except AttributeError:
                             reasoning_content = None
 
-                    if reasoning_content:
-                        if nested.getter(self.args, "show_thinking"):
-                            if not self.got_reasoning_content:
-                                text += f"<{REASONING_TAG}>\n\n"
-                            text += reasoning_content
-                            self.got_reasoning_content = True
-                            received_content = True
-                        self.token_profiler.on_token()
-                        self.io.update_spinner_suffix(reasoning_content)
-                        self.partial_response_reasoning_content += reasoning_content
-
                     try:
                         content = chunk.choices[0].delta.content
                         if content:
                             if self.got_reasoning_content and not self.ended_reasoning_content:
                                 text += f"\n\n</{self.reasoning_tag_name}>\n\n"
-                                self.ended_reasoning_content = True
 
+                            self.ended_reasoning_content = True
                             text += content
                             received_content = True
                             self.token_profiler.on_token()
@@ -3507,6 +3600,22 @@ class Coder(metaclass=UsageMeta):
                     except AttributeError:
                         pass
 
+                    if reasoning_content:
+                        if (
+                            nested.getter(self.args, "show_thinking")
+                            and not self.ended_reasoning_content
+                        ):
+                            if not self.got_reasoning_content:
+                                text += f"<{REASONING_TAG}>\n\n"
+
+                            text += reasoning_content
+                            self.got_reasoning_content = True
+                            received_content = True
+
+                        self.token_profiler.on_token()
+                        self.io.update_spinner_suffix(reasoning_content)
+                        self.partial_response_reasoning_content += reasoning_content
+
                 self.partial_response_content += text
 
                 chunk_index += 1
@@ -3533,6 +3642,16 @@ class Coder(metaclass=UsageMeta):
         except (asyncio.CancelledError, KeyboardInterrupt):
             raise KeyboardInterrupt
 
+        if (
+            self.show_pretty()
+            and nested.getter(self.args, "show_thinking")
+            and self.got_reasoning_content
+            and not self.ended_reasoning_content
+        ):
+            self.partial_response_content += f"\n\n</{self.reasoning_tag_name}>\n\n"
+            content_to_show = self.live_incremental_response(False)
+            self.stream_wrapper(content_to_show, final=False)
+
         # The Part Doing the Heavy Lifting Now
         self.consolidate_chunks()
 
@@ -3541,7 +3660,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:
@@ -3555,6 +3675,11 @@ class Coder(metaclass=UsageMeta):
         func_err = None
         content_err = None
 
+        last_chunk = self.partial_response_chunks[len(self.partial_response_chunks) - 1]
+        if last_chunk:
+            if getattr(last_chunk, "usage", None):
+                response.usage = last_chunk.usage
+
         # Collect provider-specific fields from chunks to preserve them
         # We need to track both by ID (primary) and index (fallback) since
         # early chunks might not have IDs established yet
@@ -3746,6 +3871,7 @@ class Coder(metaclass=UsageMeta):
             cache_hit_tokens = (
                 getattr(completion.usage, "prompt_cache_hit_tokens", 0)
                 or getattr(completion.usage, "cache_read_input_tokens", 0)
+                or nested.getter(completion.usage, "prompt_tokens_details.cached_tokens", 0)
                 or 0
             )
             cache_write_tokens = getattr(completion.usage, "cache_creation_input_tokens", 0) or 0