aider-ce 0.88.20__py3-none-any.whl → 0.88.38__py3-none-any.whl

aider/coders/base_coder.py

@@ -30,13 +30,7 @@ from typing import List
 
 import httpx
 from litellm import experimental_mcp_client
-from litellm.types.utils import (
-    ChatCompletionMessageToolCall,
-    Choices,
-    Function,
-    Message,
-    ModelResponse,
-)
+from litellm.types.utils import ModelResponse
 from prompt_toolkit.patch_stdout import patch_stdout
 from rich.console import Console
 
@@ -44,6 +38,7 @@ from aider import __version__, models, prompts, urls, utils
 from aider.analytics import Analytics
 from aider.commands import Commands, SwitchCoder
 from aider.exceptions import LiteLLMExceptions
+from aider.helpers import coroutines
 from aider.history import ChatSummary
 from aider.io import ConfirmGroup, InputOutput
 from aider.linter import Linter
@@ -60,6 +55,7 @@ from aider.repo import ANY_GIT_ERROR, GitRepo
 from aider.repomap import RepoMap
 from aider.run_cmd import run_cmd
 from aider.sessions import SessionManager
+from aider.tools.utils.output import print_tool_response
 from aider.utils import format_tokens, is_image_file
 
 from ..dump import dump  # noqa: F401
@@ -125,6 +121,8 @@ class Coder:
     test_outcome = None
     multi_response_content = ""
     partial_response_content = ""
+    partial_response_reasoning_content = ""
+    partial_response_chunks = []
     partial_response_tool_calls = []
     commit_before_message = []
     message_cost = 0.0
@@ -143,6 +141,9 @@ class Coder:
     compact_context_completed = True
     suppress_announcements_for_next_prompt = False
     tool_reflection = False
+    # Task coordination state variables
+    input_running = False
+    output_running = False
 
     # Context management settings (for all modes)
     context_management_enabled = False  # Disabled by default except for agent mode
@@ -240,7 +241,7 @@ class Coder:
 
     def get_announcements(self):
         lines = []
-        lines.append(f"Aider v{__version__}")
+        lines.append(f"Aider-CE v{__version__}")
 
         # Model
         main_model = self.main_model
@@ -475,6 +476,7 @@ class Coder:
         self.dry_run = dry_run
         self.pretty = self.io.pretty
         self.linear_output = linear_output
+        self.io.linear = linear_output
         self.main_model = main_model
 
         # Set the reasoning tag name based on model settings or default
@@ -492,7 +494,10 @@ class Coder:
         self.commands = commands or Commands(self.io, self)
         self.commands.coder = self
 
-        self.data_cache = {"repo": {"last_key": ""}, "relative_files": None}
+        self.data_cache = {
+            "repo": {"last_key": "", "read_only_count": None},
+            "relative_files": None,
+        }
 
         self.repo = repo
         if use_git and self.repo is None:
@@ -582,6 +587,7 @@ class Coder:
                 max_code_line_length=map_max_line_length,
                 repo_root=self.root,
                 use_memory_cache=repomap_in_memory,
+                use_enhanced_map=False if not self.args or self.args.use_enhanced_map else True,
             )
 
         self.summarizer = summarizer or ChatSummary(
@@ -678,7 +684,13 @@ class Coder:
         return True
 
     def get_abs_fnames_content(self):
-        for fname in list(self.abs_fnames):
+        # Sort files by last modified time (earliest first, latest last)
+        sorted_fnames = sorted(
+            list(filter(lambda f: os.path.exists(f), self.abs_fnames)),
+            key=lambda fname: os.path.getmtime(fname),
+        )
+
+        for fname in sorted_fnames:
             content = self.io.read_text(fname)
 
             if content is None:
@@ -724,57 +736,121 @@ class Coder:
         if not fnames:
             fnames = self.abs_fnames
 
-        prompt = ""
-        for fname, content in self.get_abs_fnames_content():
-            if not is_image_file(fname):
-                relative_fname = self.get_rel_fname(fname)
-                prompt += "\n"
-                prompt += relative_fname
-                prompt += f"\n{self.fence[0]}\n"
-
-                # Apply context management if enabled for large files
-                if self.context_management_enabled:
-                    # Calculate tokens for this file
-                    file_tokens = self.main_model.token_count(content)
-
-                    if file_tokens > self.large_file_token_threshold:
-                        # Truncate the file content
-                        lines = content.splitlines()
+        # If there are files, return a dictionary with chat_files and edit_files
+        if fnames:
+            # Get current time for comparison
+            current_time = time.time()
+            lookback = current_time - 30
 
-                        # Keep the first and last parts of the file with a marker in between
-                        keep_lines = (
-                            self.large_file_token_threshold // 40
-                        )  # Rough estimate of tokens per line
-                        first_chunk = lines[: keep_lines // 2]
-                        last_chunk = lines[-(keep_lines // 2) :]
+            # Get file modification times and sort by most recent first
+            file_times = []
+            for fname in fnames:
+                try:
+                    if os.path.exists(fname):
+                        mtime = os.path.getmtime(fname)
+                        file_times.append((fname, mtime))
+                except OSError:
+                    # Skip files that can't be accessed
+                    continue
 
-                        truncated_content = "\n".join(first_chunk)
-                        truncated_content += (
-                            f"\n\n... [File truncated due to size ({file_tokens} tokens). Use"
-                            " /context-management to toggle truncation off] ...\n\n"
-                        )
-                        truncated_content += "\n".join(last_chunk)
+            # Sort by modification time (most recent first)
+            file_times.sort(key=lambda x: x[1], reverse=True)
+
+            # Determine which files go to edit_files
+            edit_files = set()
+            if file_times:
+                # Always include the most recently edited file
+                most_recent_file, most_recent_time = file_times[0]
+                edit_files.add(most_recent_file)
+
+                # Include any files edited within the last minute
+                for fname, mtime in file_times:
+                    if mtime >= lookback:
+                        edit_files.add(fname)
+
+            # Build content for chat_files and edit_files
+            chat_files_prompt = ""
+            edit_files_prompt = ""
+            chat_file_names = set()
+            edit_file_names = set()
+
+            for fname, content in self.get_abs_fnames_content():
+                if not is_image_file(fname):
+                    relative_fname = self.get_rel_fname(fname)
+                    file_prompt = "\n"
+                    file_prompt += relative_fname
+                    file_prompt += f"\n{self.fence[0]}\n"
+
+                    # Apply context management if enabled for large files
+                    if self.context_management_enabled:
+                        # Calculate tokens for this file
+                        file_tokens = self.main_model.token_count(content)
+
+                        if file_tokens > self.large_file_token_threshold:
+                            # Truncate the file content
+                            lines = content.splitlines()
+
+                            # Keep the first and last parts of the file with a marker in between
+                            keep_lines = (
+                                self.large_file_token_threshold // 40
+                            )  # Rough estimate of tokens per line
+                            first_chunk = lines[: keep_lines // 2]
+                            last_chunk = lines[-(keep_lines // 2) :]
+
+                            truncated_content = "\n".join(first_chunk)
+                            truncated_content += (
+                                f"\n\n... [File truncated due to size ({file_tokens} tokens). Use"
+                                " /context-management to toggle truncation off] ...\n\n"
+                            )
+                            truncated_content += "\n".join(last_chunk)
 
-                        # Add message about truncation
-                        self.io.tool_output(
-                            f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
-                            "Use /context-management to toggle truncation off if needed."
-                        )
+                            # Add message about truncation
+                            self.io.tool_output(
+                                f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
+                                "Use /context-management to toggle truncation off if needed."
+                            )
 
-                        prompt += truncated_content
+                            file_prompt += truncated_content
+                        else:
+                            file_prompt += content
                     else:
-                        prompt += content
-                else:
-                    prompt += content
+                        file_prompt += content
 
-                prompt += f"{self.fence[1]}\n"
+                    file_prompt += f"{self.fence[1]}\n"
 
-        return prompt
+                    # Add to appropriate prompt based on edit time
+                    if fname in edit_files:
+                        edit_files_prompt += file_prompt
+                        edit_file_names.add(relative_fname)
+                    else:
+                        chat_files_prompt += file_prompt
+                        chat_file_names.add(relative_fname)
+
+            return {
+                "chat_files": chat_files_prompt,
+                "edit_files": edit_files_prompt,
+                "chat_file_names": chat_file_names,
+                "edit_file_names": edit_file_names,
+            }
+        else:
+            # Return empty dictionary when no files
+            return {
+                "chat_files": "",
+                "edit_files": "",
+                "chat_file_names": set(),
+                "edit_file_names": set(),
+            }
 
     def get_read_only_files_content(self):
         prompt = ""
+        # Sort read-only files by last modified time (earliest first, latest last)
+        sorted_fnames = sorted(
+            list(filter(lambda f: os.path.exists(f), self.abs_read_only_fnames)),
+            key=lambda fname: os.path.getmtime(fname),
+        )
+
         # Handle regular read-only files
-        for fname in self.abs_read_only_fnames:
+        for fname in sorted_fnames:
             content = self.io.read_text(fname)
             if content is not None and not is_image_file(fname):
                 relative_fname = self.get_rel_fname(fname)
@@ -819,8 +895,14 @@ class Coder:
 
                 prompt += f"{self.fence[1]}\n"
 
+        # Sort stub files by last modified time (earliest first, latest last)
+        sorted_stub_fnames = sorted(
+            list(filter(lambda f: os.path.exists(f), self.abs_read_only_stubs_fnames)),
+            key=lambda fname: os.path.getmtime(fname),
+        )
+
         # Handle stub files
-        for fname in self.abs_read_only_stubs_fnames:
+        for fname in sorted_stub_fnames:
             if not is_image_file(fname):
                 relative_fname = self.get_rel_fname(fname)
                 prompt += "\n"
@@ -878,7 +960,16 @@ class Coder:
         self.io.update_spinner("Updating repo map")
 
         cur_msg_text = self.get_cur_message_text()
-        staged_files_hash = hash(str([item.a_path for item in self.repo.repo.index.diff("HEAD")]))
+        try:
+            staged_files_hash = hash(
+                str([item.a_path for item in self.repo.repo.index.diff("HEAD")])
+            )
+        except ANY_GIT_ERROR as err:
+            # Handle git errors gracefully - use a fallback hash
+            if self.verbose:
+                self.io.tool_warning(f"Git error while checking staged files for repo map: {err}")
+            staged_files_hash = hash(str(time.time()))  # Use timestamp as fallback
+
         read_only_count = len(set(self.abs_read_only_fnames)) + len(
             set(self.abs_read_only_stubs_fnames)
         )
@@ -889,7 +980,6 @@ class Coder:
             or read_only_count != self.data_cache["repo"]["read_only_count"]
         ):
             self.data_cache["repo"]["last_key"] = staged_files_hash
-
             mentioned_idents = self.data_cache["repo"]["mentioned_idents"]
             mentioned_fnames = self.get_file_mentions(cur_msg_text)
             mentioned_fnames.update(self.get_ident_filename_matches(mentioned_idents))
@@ -907,7 +997,7 @@ class Coder:
                     return False
                 if ".min." in parts[-1]:
                     return False
-                if self.repo.git_ignored_file(abs_path):
+                if self.repo.ignored_file(abs_path):
                     return False
                 return True
 
@@ -1001,22 +1091,56 @@ class Coder:
 
     def get_chat_files_messages(self):
         chat_files_messages = []
+        edit_files_messages = []
+        chat_file_names = set()
+        edit_file_names = set()
+
         if self.abs_fnames:
-            files_content = self.gpt_prompts.files_content_prefix
-            files_content += self.get_files_content()
+            files_content_result = self.get_files_content()
+
+            # Get content and file names from dictionary
+            chat_files_content = files_content_result.get("chat_files", "")
+            edit_files_content = files_content_result.get("edit_files", "")
+            chat_file_names = files_content_result.get("chat_file_names", set())
+            edit_file_names = files_content_result.get("edit_file_names", set())
+
             files_reply = self.gpt_prompts.files_content_assistant_reply
+
+            if chat_files_content:
+                chat_files_messages += [
+                    dict(
+                        role="user",
+                        content=self.gpt_prompts.files_content_prefix + chat_files_content,
+                    ),
+                    dict(role="assistant", content=files_reply),
+                ]
+
+            if edit_files_content:
+                edit_files_messages += [
+                    dict(
+                        role="user",
+                        content=self.gpt_prompts.files_content_prefix + edit_files_content,
+                    ),
+                    dict(role="assistant", content=files_reply),
+                ]
         elif self.gpt_prompts.files_no_full_files_with_repo_map:
             files_content = self.gpt_prompts.files_no_full_files_with_repo_map
             files_reply = self.gpt_prompts.files_no_full_files_with_repo_map_reply
+
+            if files_content:
+                chat_files_messages += [
+                    dict(role="user", content=files_content),
+                    dict(role="assistant", content=files_reply),
+                ]
         else:
             files_content = self.gpt_prompts.files_no_full_files
             files_reply = "Ok."
 
-        if files_content:
-            chat_files_messages += [
-                dict(role="user", content=files_content),
-                dict(role="assistant", content=files_reply),
-            ]
+            if files_content:
+                chat_files_messages += [
+                    dict(role="user", content=files_content),
+                    dict(role="assistant", content=files_reply),
+                ]
 
         images_message = self.get_images_message(self.abs_fnames)
         if images_message is not None:
@@ -1025,7 +1149,12 @@ class Coder:
                 dict(role="assistant", content="Ok."),
             ]
 
-        return chat_files_messages
+        return {
+            "chat_files": chat_files_messages,
+            "edit_files": edit_files_messages,
+            "chat_file_names": chat_file_names,
+            "edit_file_names": edit_file_names,
+        }
 
     def get_images_message(self, fnames):
         supports_images = self.main_model.info.get("supports_vision")
@@ -1096,9 +1225,9 @@ class Coder:
 
         if self.io.prompt_session:
             with patch_stdout(raw=True):
-                return await self._run_patched(with_message, preproc)
+                return await self._run_parallel(with_message, preproc)
         else:
-            return await self._run_patched(with_message, preproc)
+            return await self._run_parallel(with_message, preproc)
 
     async def _run_linear(self, with_message=None, preproc=True):
         try:
@@ -1108,8 +1237,7 @@ class Coder:
                 return self.partial_response_content
 
             user_message = None
-            await self.io.cancel_input_task()
-            await self.io.cancel_output_task()
+            await self.io.stop_task_streams()
 
             while True:
                 try:
@@ -1124,186 +1252,218 @@ class Coder:
                     await self.io.recreate_input()
                     await self.io.input_task
                     user_message = self.io.input_task.result()
-
-                    self.io.output_task = asyncio.create_task(self._generate(user_message, preproc))
+                    self.io.tool_output("Processing...\n")
+                    self.io.output_task = asyncio.create_task(self.generate(user_message, preproc))
 
                     await self.io.output_task
-
+                    self.io.tool_output("Finished.")
                     self.io.ring_bell()
                     user_message = None
-                except KeyboardInterrupt:
-                    if self.io.input_task:
-                        self.io.set_placeholder("")
-                        await self.io.cancel_input_task()
-
-                    if self.io.output_task:
-                        await self.io.cancel_output_task()
-                        self.io.stop_spinner()
+                    await self.auto_save_session()
 
+                except KeyboardInterrupt:
+                    self.io.set_placeholder("")
+                    self.io.stop_spinner()
                     self.keyboard_interrupt()
+                    await self.io.stop_task_streams()
                 except (asyncio.CancelledError, IndexError):
                     pass
 
-            self.auto_save_session()
         except EOFError:
             return
         finally:
-            await self.io.cancel_input_task()
-            await self.io.cancel_output_task()
+            await self.io.stop_task_streams()
 
-    async def _run_patched(self, with_message=None, preproc=True):
+    async def _run_parallel(self, with_message=None, preproc=True):
         try:
             if with_message:
                 self.io.user_input(with_message)
                 await self.run_one(with_message, preproc)
                 return self.partial_response_content
 
-            user_message = None
+            # Initialize state for task coordination
+            self.input_running = True
+            self.output_running = True
             self.user_message = ""
-            await self.io.cancel_input_task()
-            await self.io.cancel_output_task()
 
-            while True:
-                try:
-                    if (
-                        not self.io.confirmation_in_progress
-                        and not user_message
-                        and (
-                            not self.io.input_task
-                            or self.io.input_task.done()
-                            or self.io.input_task.cancelled()
-                        )
-                        and (not self.io.output_task or not self.io.placeholder)
-                    ):
-                        if not self.suppress_announcements_for_next_prompt:
-                            self.show_announcements()
-                        self.suppress_announcements_for_next_prompt = True
-
-                        # Stop spinner before showing announcements or getting input
-                        self.io.stop_spinner()
-                        self.copy_context()
-                        await self.io.recreate_input()
+            # Cancel any existing tasks
+            await self.io.stop_task_streams()
 
-                    if self.user_message:
-                        self.io.output_task = asyncio.create_task(
-                            self._generate(self.user_message, preproc)
-                        )
+            # Start the input and output tasks
+            input_task = asyncio.create_task(self.input_task(preproc))
+            output_task = asyncio.create_task(self.output_task(preproc))
 
-                        self.user_message = ""
-                        # Start spinner for processing task
-                        self.io.start_spinner("Processing...")
-
-                    if self.commands.cmd_running:
-                        await asyncio.sleep(0.1)
-                        continue
-
-                    tasks = set()
+            try:
+                # Wait for both tasks to complete or for one to raise an exception
+                done, pending = await asyncio.wait(
+                    [input_task, output_task], return_when=asyncio.FIRST_EXCEPTION
+                )
 
-                    if self.io.output_task:
-                        if self.io.output_task.done():
-                            exception = self.io.output_task.exception()
-                            if exception:
-                                if isinstance(exception, SwitchCoder):
-                                    await self.io.output_task
-                        elif not self.io.output_task.done() and not self.io.output_task.cancelled():
-                            tasks.add(self.io.output_task)
+                # Check for exceptions
+                for task in done:
+                    if task.exception():
+                        raise task.exception()
 
-                    if (
-                        self.io.input_task
-                        and not self.io.input_task.done()
-                        and not self.io.input_task.cancelled()
-                    ):
-                        tasks.add(self.io.input_task)
+            except (SwitchCoder, SystemExit):
+                # Re-raise SwitchCoder to be handled by outer try block
+                raise
+            except KeyboardInterrupt:
+                # Handle keyboard interrupt gracefully
+                self.io.set_placeholder("")
+                self.io.stop_spinner()
+                self.keyboard_interrupt()
+            finally:
+                # Signal tasks to stop
+                self.input_running = False
+                self.output_running = False
+
+                # Cancel tasks
+                input_task.cancel()
+                output_task.cancel()
+
+                # Wait for tasks to finish
+                try:
+                    await asyncio.gather(input_task, output_task, return_exceptions=True)
+                except (asyncio.CancelledError, KeyboardInterrupt):
+                    pass
 
-                    if tasks:
-                        done, pending = await asyncio.wait(
-                            tasks, return_when=asyncio.FIRST_COMPLETED
-                        )
+                # Ensure IO tasks are properly cancelled
+                await self.io.stop_task_streams()
 
-                        if self.io.input_task and self.io.input_task in done:
-                            if self.io.output_task:
-                                if not self.io.confirmation_in_progress:
-                                    await self.io.cancel_output_task()
-                                    self.io.stop_spinner()
+            await self.auto_save_session()
+        except EOFError:
+            return
+        finally:
+            await self.io.stop_task_streams()
 
-                            try:
-                                if self.io.input_task:
-                                    user_message = self.io.input_task.result()
-                                    await self.io.cancel_input_task()
+    async def input_task(self, preproc):
+        """
+        Handles input creation/recreation and user message processing.
+        This task manages the input loop and coordinates with output_task.
+        """
+        while self.input_running:
+            try:
+                # Wait for commands to finish
+                if self.commands.cmd_running:
+                    await asyncio.sleep(0.1)
+                    continue
 
-                                if self.commands.is_run_command(user_message):
-                                    self.commands.cmd_running = True
+                # Wait for input task completion
+                if self.io.input_task and self.io.input_task.done():
+                    try:
+                        user_message = self.io.input_task.result()
+
+                        # Set user message for output task
+                        if not self.io.acknowledge_confirmation():
+                            if user_message:
+                                self.user_message = user_message
+                                await self.auto_save_session()
+                            else:
+                                self.user_message = ""
+                                await self.io.stop_task_streams()
+
+                    except (asyncio.CancelledError, KeyboardInterrupt):
+                        self.user_message = ""
+                        await self.io.stop_task_streams()
 
-                            except (asyncio.CancelledError, KeyboardInterrupt):
-                                user_message = None
+                # Check if we should show announcements
+                if (
+                    not self.io.confirmation_in_progress
+                    and not self.user_message
+                    and not coroutines.is_active(self.io.input_task)
+                    and (not coroutines.is_active(self.io.output_task) or not self.io.placeholder)
+                ):
+                    if not self.suppress_announcements_for_next_prompt:
+                        self.show_announcements()
+                    self.suppress_announcements_for_next_prompt = True
 
-                            if not user_message:
-                                await self.io.cancel_input_task()
-                                continue
+                    # Stop spinner before showing announcements or getting input
+                    self.io.stop_spinner()
+                    self.copy_context()
 
-                        if self.io.output_task and self.io.output_task in pending:
-                            try:
-                                tasks = set()
-                                tasks.add(self.io.output_task)
+                # Check if we should recreate input
+                if not coroutines.is_active(self.io.input_task):
+                    self.io.ring_bell()
+                    await self.io.recreate_input()
 
-                                # We just did a confirmation so add a new input task
-                                if self.io.get_confirmation_acknowledgement():
-                                    await self.io.recreate_input()
-                                    tasks.add(self.io.input_task)
+                await asyncio.sleep(0.01)  # Small yield to prevent tight loop
 
-                                done, pending = await asyncio.wait(
-                                    tasks, return_when=asyncio.FIRST_COMPLETED
-                                )
+            except KeyboardInterrupt:
+                self.io.set_placeholder("")
+                self.keyboard_interrupt()
+                await self.io.stop_task_streams()
+            except (SwitchCoder, SystemExit):
+                raise
+            except Exception as e:
+                if self.verbose or self.args.debug:
+                    print(e)
 
-                                if (
-                                    self.io.input_task
-                                    and self.io.input_task in done
-                                    and not self.io.confirmation_in_progress
-                                ):
-                                    await self.io.cancel_output_task()
-                                    self.io.stop_spinner()
-                                    self.io.acknowledge_confirmation()
+    async def output_task(self, preproc):
+        """
+        Handles output task generation and monitoring.
+        This task manages the output loop and coordinates with input_task.
+        """
+        while self.output_running:
+            try:
+                # Wait for commands to finish
+                if self.commands.cmd_running:
+                    await asyncio.sleep(0.1)
+                    continue
 
-                                    try:
-                                        user_message = self.io.input_task.result()
-                                        await self.io.cancel_input_task()
-                                    except (asyncio.CancelledError, KeyboardInterrupt):
-                                        user_message = None
+                # Check if we have a user message to process
+                if self.user_message and not self.io.get_confirmation_acknowledgement():
+                    user_message = self.user_message
+                    self.user_message = ""
 
-                            except (asyncio.CancelledError, KeyboardInterrupt):
-                                pass
+                    # Create output task for processing
+                    self.io.output_task = asyncio.create_task(self.generate(user_message, preproc))
 
-                            # Stop spinner when processing task completes
-                            self.io.stop_spinner()
+                    # Start spinner for output task
+                    self.io.start_spinner("Processing...")
+                    await self.io.recreate_input()
 
-                    if user_message and not self.io.acknowledge_confirmation():
-                        self.user_message = user_message
+                # Monitor output task
+                if self.io.output_task:
+                    if self.io.output_task.done():
+                        exception = self.io.output_task.exception()
+                        if exception:
+                            if isinstance(exception, SwitchCoder):
+                                await self.io.output_task
+                                raise exception
+
+                            self.io.tool_error(f"Error during generation: {exception}")
+                            if self.verbose:
+                                traceback.print_exception(
+                                    type(exception), exception, exception.__traceback__
+                                )
 
-                    self.io.ring_bell()
-                    user_message = None
-                except KeyboardInterrupt:
-                    self.io.set_placeholder("")
+                        # Stop spinner when processing task completes
+                        self.io.stop_spinner()
 
-                    await self.io.cancel_input_task()
-                    await self.io.cancel_output_task()
+                        # And stop monitoring the output task
+                        await self.io.stop_output_task()
 
-                    self.io.stop_spinner()
-                    self.keyboard_interrupt()
+                await self.auto_save_session()
+                await asyncio.sleep(0.01)  # Small yield to prevent tight loop
 
-                self.auto_save_session()
-        except EOFError:
-            return
-        finally:
-            await self.io.cancel_input_task()
-            await self.io.cancel_output_task()
+            except KeyboardInterrupt:
+                self.io.stop_spinner()
+                self.keyboard_interrupt()
+                await self.io.stop_task_streams()
+            except (SwitchCoder, SystemExit):
+                raise
+            except Exception as e:
+                if self.verbose or self.args.debug:
+                    print(e)
 
-    async def _generate(self, user_message, preproc):
+    async def generate(self, user_message, preproc):
         await asyncio.sleep(0.1)
 
         try:
-            self.compact_context_completed = False
-            await self.compact_context_if_needed()
-            self.compact_context_completed = True
+            if not self.enable_context_compaction:
+                self.compact_context_completed = False
+                await self.compact_context_if_needed()
+                self.compact_context_completed = True
 
             self.run_one_completed = False
             await self.run_one(user_message, preproc)
@@ -1393,6 +1553,9 @@ class Coder:
             else:
                 message = self.reflected_message
 
+            if self.enable_context_compaction:
+                await self.compact_context_if_needed()
+
     async def check_and_open_urls(self, exc, friendly_msg=None):
         """Check exception for URLs, offer to open in a browser, with user-friendly error msgs."""
         text = str(exc)
@@ -1485,38 +1648,81 @@ class Coder:
             self.summarize_start()
             return
 
-        if not self.summarizer.check_max_tokens(
-            self.done_messages, max_tokens=self.context_compaction_max_tokens
-        ):
+        # Check if combined messages exceed the token limit,
+        # Exclude first cur_message since that's the user's initial input
+        done_tokens = self.summarizer.count_tokens(self.done_messages)
+        cur_tokens = self.summarizer.count_tokens(self.cur_messages[1:])
+        combined_tokens = done_tokens + cur_tokens
+
+        if combined_tokens < self.context_compaction_max_tokens:
             return
 
         self.io.tool_output("Compacting chat history to make room for new messages...")
+        self.io.update_spinner("Compacting...")
 
         try:
-            # Create a summary of the conversation
-            summary_text = await self.summarizer.summarize_all_as_text(
-                self.done_messages,
-                self.gpt_prompts.compaction_prompt,
-                self.context_compaction_summary_tokens,
-            )
-            if not summary_text:
-                raise ValueError("Summarization returned an empty result.")
+            # Check if done_messages alone exceed the limit
+            if done_tokens > self.context_compaction_max_tokens or done_tokens > cur_tokens:
+                # Create a summary of the done_messages
+                summary_text = await self.summarizer.summarize_all_as_text(
+                    self.done_messages,
+                    self.gpt_prompts.compaction_prompt,
+                    self.context_compaction_summary_tokens,
+                )
+
+                if not summary_text:
+                    raise ValueError("Summarization returned an empty result.")
+
+                # Replace old messages with the summary
+                self.done_messages = [
+                    {
+                        "role": "user",
+                        "content": summary_text,
+                    },
+                    {
+                        "role": "assistant",
+                        "content": (
+                            "Ok, I will use this summary as the context for our conversation going"
+                            " forward."
+                        ),
+                    },
+                ]
+
+            # Check if cur_messages alone exceed the limit (after potentially compacting done_messages)
+            if cur_tokens > self.context_compaction_max_tokens or cur_tokens > done_tokens:
+                # Create a summary of the cur_messages
+                cur_summary_text = await self.summarizer.summarize_all_as_text(
+                    self.cur_messages,
+                    self.gpt_prompts.compaction_prompt,
+                    self.context_compaction_summary_tokens,
+                )
+
+                if not cur_summary_text:
+                    raise ValueError("Summarization of current messages returned an empty result.")
+
+                # Replace current messages with the summary
+                self.cur_messages = [
+                    self.cur_messages[0],
+                    {
+                        "role": "assistant",
+                        "content": "Ok. I am awaiting your summary of our goals to proceed.",
+                    },
+                    {
+                        "role": "user",
+                        "content": f"Here is a summary of our current goals:\n{cur_summary_text}",
+                    },
+                    {
+                        "role": "assistant",
+                        "content": (
+                            "Ok, I will use this summary and proceed with our task."
+                            " I will first apply any changes in the summary and then"
+                            " continue exploration as necessary."
+                        ),
+                    },
+                ]
 
-            # Replace old messages with the summary
-            self.done_messages = [
-                {
-                    "role": "user",
-                    "content": summary_text,
-                },
-                {
-                    "role": "assistant",
-                    "content": (
-                        "Ok, I will use this summary as the context for our conversation going"
-                        " forward."
-                    ),
-                },
-            ]
             self.io.tool_output("...chat history compacted.")
+            self.io.update_spinner(self.io.last_spinner_text)
         except Exception as e:
             self.io.tool_warning(f"Context compaction failed: {e}")
             self.io.tool_warning("Proceeding with full history for now.")
@@ -1781,7 +1987,11 @@ class Coder:
 
         chunks.repo = self.get_repo_messages()
         chunks.readonly_files = self.get_readonly_files_messages()
-        chunks.chat_files = self.get_chat_files_messages()
+
+        # Handle the dictionary structure from get_chat_files_messages()
+        chat_files_result = self.get_chat_files_messages()
+        chunks.chat_files = chat_files_result.get("chat_files", [])
+        chunks.edit_files = chat_files_result.get("edit_files", [])
 
         if self.gpt_prompts.system_reminder:
             reminder_message = [
@@ -1919,7 +2129,7 @@ class Coder:
                 " the context limit is exceeded."
             )
 
-            if not await self.io.confirm_ask("Try to proceed anyway?"):
+            if not await self.io.confirm_ask("Try to proceed anyway?", explicit_yes_required=True):
                 return False
         return True
 
@@ -2039,9 +2249,7 @@ class Coder:
             self.multi_response_content = ""
 
         self.io.tool_output()
-
         self.show_usage_report()
-
         self.add_assistant_reply_to_cur_messages()
 
         if exhausted:
@@ -2101,43 +2309,7 @@ class Coder:
             # Process any tools using MCP servers
             try:
                 if self.partial_response_tool_calls:
-                    tool_calls = []
-                    tool_id_set = set()
-
-                    for tool_call_dict in self.partial_response_tool_calls:
-                        # LLM APIs sometimes return duplicates and that's annoying
-                        if tool_call_dict.get("id") in tool_id_set:
-                            continue
-
-                        tool_id_set.add(tool_call_dict.get("id"))
-
-                        tool_calls.append(
-                            ChatCompletionMessageToolCall(
-                                id=tool_call_dict.get("id"),
-                                function=Function(
-                                    name=tool_call_dict.get("function", {}).get("name"),
-                                    arguments=tool_call_dict.get("function", {}).get(
-                                        "arguments", ""
-                                    ),
-                                ),
-                                type=tool_call_dict.get("type"),
-                            )
-                        )
-
-                    tool_call_response = ModelResponse(
-                        choices=[
-                            Choices(
-                                finish_reason="tool_calls",
-                                index=0,
-                                message=Message(
-                                    content=None,
-                                    role="assistant",
-                                    tool_calls=tool_calls,
-                                ),
-                            )
-                        ]
-                    )
-
+                    tool_call_response, a, b = self.consolidate_chunks()
                     if await self.process_tool_calls(tool_call_response):
                         self.num_tool_calls += 1
                         self.reflected_message = True
@@ -2244,7 +2416,6 @@ class Coder:
             self._print_tool_call_info(server_tool_calls)
 
             if await self.io.confirm_ask("Run tools?", group_response="Run MCP Tools"):
-                await self.io.recreate_input()
                 tool_responses = await self._execute_tool_calls(server_tool_calls)
 
                 # Add all tool responses
@@ -2263,54 +2434,14 @@ class Coder:
 
         for server, tool_calls in server_tool_calls.items():
             for tool_call in tool_calls:
-                color_start = "[blue]" if self.pretty else ""
-                color_end = "[/blue]" if self.pretty else ""
-
-                self.io.tool_output(
-                    f"{color_start}Tool Call:{color_end} {server.name} • {tool_call.function.name}"
-                )
-                # Parse and format arguments as headers with values
-                if tool_call.function.arguments:
-                    # Only do JSON unwrapping for tools containing "replace" in their name
-                    if (
-                        "replace" in tool_call.function.name.lower()
-                        or "insert" in tool_call.function.name.lower()
-                        or "update" in tool_call.function.name.lower()
-                    ):
-                        try:
-                            args_dict = json.loads(tool_call.function.arguments)
-                            first_key = True
-                            for key, value in args_dict.items():
-                                # Convert explicit \\n sequences to actual newlines using regex
-                                # Only match \\n that is not preceded by any other backslashes
-                                if isinstance(value, str):
-                                    value = re.sub(r"(?<!\\)\\n", "\n", value)
-                                # Add extra newline before first key/header
-                                if first_key:
-                                    self.io.tool_output("\n")
-                                    first_key = False
-                                self.io.tool_output(f"{color_start}{key}:{color_end}")
-                                # Split the value by newlines and output each line separately
-                                if isinstance(value, str):
-                                    for line in value.split("\n"):
-                                        self.io.tool_output(f"{line}")
-                                else:
-                                    self.io.tool_output(f"{str(value)}")
-                                self.io.tool_output("")
-                        except json.JSONDecodeError:
-                            # If JSON parsing fails, show raw arguments
-                            raw_args = tool_call.function.arguments
-                            self.io.tool_output(f"{color_start}Arguments:{color_end} {raw_args}")
-                    else:
-                        # For non-replace tools, show raw arguments
-                        raw_args = tool_call.function.arguments
-                        self.io.tool_output(f"{color_start}Arguments:{color_end} {raw_args}")
-
-                if self.verbose:
-                    self.io.tool_output(f"Tool ID: {tool_call.id}")
-                    self.io.tool_output(f"Tool type: {tool_call.type}")
-
-                self.io.tool_output("\n")
+                if hasattr(self, "tool_registry") and self.tool_registry.get(
+                    tool_call.function.name.lower(), None
+                ):
+                    self.tool_registry.get(tool_call.function.name.lower()).format_output(
+                        coder=self, mcp_server=server, tool_response=tool_call
+                    )
+                else:
+                    print_tool_response(coder=self, mcp_server=server, tool_response=tool_call)
 
     def _gather_server_tool_calls(self, tool_calls):
         """Collect all tool calls grouped by server.
@@ -2662,18 +2793,26 @@ class Coder:
         to be `None` when `tool_calls` are present.
         """
         msg = dict(role="assistant")
-        has_tool_calls = self.partial_response_tool_calls or self.partial_response_function_call
+        response = (
+            self.partial_response_chunks[0]
+            if not self.stream
+            else litellm.stream_chunk_builder(self.partial_response_chunks)
+        )
 
-        # If we have tool calls and we're using a Deepseek model, force content to be None.
-        if has_tool_calls and self.main_model.is_deepseek():
-            msg["content"] = None
-        else:
-            # Otherwise, use logic similar to the base implementation.
-            content = self.partial_response_content
-            if content:
-                msg["content"] = content
-            elif has_tool_calls:
-                msg["content"] = None
+        try:
+            # Use response_dict as a regular dictionary
+            response_dict = response.model_dump()
+        except AttributeError:
+            # Option 2: Fall back to dict() or response.dict() (Pydantic V1 style)
+            try:
+                # Note: calling dict(response) works in both V1 and V2 for raw fields,
+                # but response.dict() is the Pydantic V1 method name.
+                response_dict = dict(response)
+            except TypeError:
+                print("Neither model_dump() nor dict() worked as expected.")
+                raise
+
+        msg = response_dict["choices"][0]["message"]
 
         if self.partial_response_tool_calls:
             msg["tool_calls"] = self.partial_response_tool_calls
@@ -2681,7 +2820,7 @@ class Coder:
             msg["function_call"] = self.partial_response_function_call
 
         # Only add a message if it's not empty.
-        if msg.get("content") is not None or msg.get("tool_calls") or msg.get("function_call"):
+        if msg is not None:
             self.cur_messages.append(msg)
 
     def get_file_mentions(self, content, ignore_current=False):
@@ -2746,7 +2885,6 @@ class Coder:
             if await self.io.confirm_ask(
                 "Add file to the chat?", subject=rel_fname, group=group, allow_never=True
             ):
-                await self.io.recreate_input()
                 self.add_rel_fname(rel_fname)
                 added_fnames.append(rel_fname)
             else:
@@ -2766,8 +2904,10 @@ class Coder:
             model = self.main_model
 
         self.partial_response_content = ""
-        self.partial_response_function_call = dict()
+        self.partial_response_reasoning_content = ""
+        self.partial_response_chunks = []
         self.partial_response_tool_calls = []
+        self.partial_response_function_call = dict()
 
         completion = None
 
@@ -2823,28 +2963,9 @@ class Coder:
             self.io.tool_error(str(completion))
             return
 
-        show_func_err = None
-        show_content_err = None
-        try:
-            if completion.choices[0].message.tool_calls:
-                self.partial_response_function_call = (
-                    completion.choices[0].message.tool_calls[0].function
-                )
-        except AttributeError as func_err:
-            show_func_err = func_err
-
-        try:
-            reasoning_content = completion.choices[0].message.reasoning_content
-        except AttributeError:
-            try:
-                reasoning_content = completion.choices[0].message.reasoning
-            except AttributeError:
-                reasoning_content = None
+        self.partial_response_chunks.append(completion)
 
-        try:
-            self.partial_response_content = completion.choices[0].message.content or ""
-        except AttributeError as content_err:
-            show_content_err = content_err
+        response, func_err, content_err = self.consolidate_chunks()
 
         resp_hash = dict(
             function_call=str(self.partial_response_function_call),
@@ -2853,16 +2974,16 @@ class Coder:
         resp_hash = hashlib.sha1(json.dumps(resp_hash, sort_keys=True).encode())
         self.chat_completion_response_hashes.append(resp_hash.hexdigest())
 
-        if show_func_err and show_content_err:
-            self.io.tool_error(show_func_err)
-            self.io.tool_error(show_content_err)
+        if func_err and content_err:
+            self.io.tool_error(func_err)
+            self.io.tool_error(content_err)
             raise Exception("No data found in LLM response!")
 
         show_resp = self.render_incremental_response(True)
 
-        if reasoning_content:
+        if self.partial_response_reasoning_content:
             formatted_reasoning = format_reasoning_content(
-                reasoning_content, self.reasoning_tag_name
+                self.partial_response_reasoning_content, self.reasoning_tag_name
             )
             show_resp = formatted_reasoning + show_resp
 
@@ -2903,43 +3024,18 @@ class Coder:
                         for tool_call_chunk in chunk.choices[0].delta.tool_calls:
                             self.tool_reflection = True
 
-                            index = tool_call_chunk.index
-                            if len(self.partial_response_tool_calls) <= index:
-                                self.partial_response_tool_calls.extend(
-                                    [{}] * (index - len(self.partial_response_tool_calls) + 1)
-                                )
-
-                            if tool_call_chunk.id:
-                                self.partial_response_tool_calls[index]["id"] = tool_call_chunk.id
                             if tool_call_chunk.type:
-                                self.partial_response_tool_calls[index][
-                                    "type"
-                                ] = tool_call_chunk.type
+                                self.io.update_spinner_suffix(tool_call_chunk.type)
+
                             if tool_call_chunk.function:
-                                if "function" not in self.partial_response_tool_calls[index]:
-                                    self.partial_response_tool_calls[index]["function"] = {}
                                 if tool_call_chunk.function.name:
-                                    if (
-                                        "name"
-                                        not in self.partial_response_tool_calls[index]["function"]
-                                    ):
-                                        self.partial_response_tool_calls[index]["function"][
-                                            "name"
-                                        ] = ""
-                                    self.partial_response_tool_calls[index]["function"][
-                                        "name"
-                                    ] += tool_call_chunk.function.name
+                                    self.io.update_spinner_suffix(tool_call_chunk.function.name)
+
                                 if tool_call_chunk.function.arguments:
-                                    if (
-                                        "arguments"
-                                        not in self.partial_response_tool_calls[index]["function"]
-                                    ):
-                                        self.partial_response_tool_calls[index]["function"][
-                                            "arguments"
-                                        ] = ""
-                                    self.partial_response_tool_calls[index]["function"][
-                                        "arguments"
-                                    ] += tool_call_chunk.function.arguments
+                                    self.io.update_spinner_suffix(
+                                        tool_call_chunk.function.arguments
+                                    )
+
                 except (AttributeError, IndexError):
                     # Handle cases where the response structure doesn't match expectations
                     pass
@@ -2949,11 +3045,7 @@ class Coder:
                     # dump(func)
                     for k, v in func.items():
                         self.tool_reflection = True
-
-                        if k in self.partial_response_function_call:
-                            self.partial_response_function_call[k] += v
-                        else:
-                            self.partial_response_function_call[k] = v
+                        self.io.update_spinner_suffix(v)
 
                     received_content = True
                 except AttributeError:
@@ -2975,6 +3067,8 @@ class Coder:
                     text += reasoning_content
                     self.got_reasoning_content = True
                     received_content = True
+                    self.io.update_spinner_suffix(reasoning_content)
+                    self.partial_response_reasoning_content += reasoning_content
 
                 try:
                     content = chunk.choices[0].delta.content
@@ -2985,10 +3079,14 @@ class Coder:
 
                         text += content
                         received_content = True
+                        self.io.update_spinner_suffix(content)
                 except AttributeError:
                     pass
 
             self.partial_response_content += text
+
+            self.partial_response_chunks.append(chunk)
+
             if self.show_pretty():
                 # Use simplified streaming - just call the method with full content
                 content_to_show = self.live_incremental_response(False)
@@ -3006,9 +3104,111 @@ class Coder:
                     self.stream_wrapper(safe_text, final=False)
                 yield text
 
+        # The Part Doing the Heavy Lifting Now
+        self.consolidate_chunks()
+
         if not received_content and len(self.partial_response_tool_calls) == 0:
             self.io.tool_warning("Empty response received from LLM. Check your provider account?")
 
+    def consolidate_chunks(self):
+        response = (
+            self.partial_response_chunks[0]
+            if not self.stream
+            else litellm.stream_chunk_builder(self.partial_response_chunks)
+        )
+        func_err = None
+        content_err = None
+
+        # 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
+        provider_specific_fields_by_id = {}
+        provider_specific_fields_by_index = {}
+
+        for chunk in self.partial_response_chunks:
+            try:
+                if chunk.choices and chunk.choices[0].delta and chunk.choices[0].delta.tool_calls:
+                    for tool_call in chunk.choices[0].delta.tool_calls:
+                        if (
+                            hasattr(tool_call, "provider_specific_fields")
+                            and tool_call.provider_specific_fields
+                        ):
+                            # Ensure provider_specific_fields is a dictionary
+                            psf = tool_call.provider_specific_fields
+                            if not isinstance(psf, dict):
+                                continue
+
+                            # Try to use ID first
+                            if hasattr(tool_call, "id") and tool_call.id:
+                                tool_id = tool_call.id
+                                if tool_id not in provider_specific_fields_by_id:
+                                    provider_specific_fields_by_id[tool_id] = {}
+                                # Merge provider-specific fields for this tool ID
+                                provider_specific_fields_by_id[tool_id].update(psf)
+                            # Also track by index as fallback
+                            elif hasattr(tool_call, "index"):
+                                tool_index = tool_call.index
+                                if tool_index not in provider_specific_fields_by_index:
+                                    provider_specific_fields_by_index[tool_index] = {}
+                                provider_specific_fields_by_index[tool_index].update(psf)
+            except (AttributeError, IndexError):
+                continue
+
+        try:
+            if response.choices[0].message.tool_calls:
+                for i, tool_call in enumerate(response.choices[0].message.tool_calls):
+                    # Add provider-specific fields if we collected any for this tool
+                    tool_id = tool_call.id
+
+                    # Try ID first
+                    if tool_id in provider_specific_fields_by_id:
+                        # Add provider-specific fields directly to the tool call object
+                        tool_call.provider_specific_fields = provider_specific_fields_by_id[tool_id]
+                    # Fall back to index
+                    elif i in provider_specific_fields_by_index:
+                        # Add provider-specific fields directly to the tool call object
+                        tool_call.provider_specific_fields = provider_specific_fields_by_index[i]
+
+                    # Create dictionary version with provider-specific fields
+                    tool_call_dict = tool_call.model_dump()
+
+                    # Add provider-specific fields to the dictionary too (in case model_dump() doesn't include them)
+                    if tool_id in provider_specific_fields_by_id:
+                        tool_call_dict["provider_specific_fields"] = provider_specific_fields_by_id[
+                            tool_id
+                        ]
+                    elif i in provider_specific_fields_by_index:
+                        tool_call_dict["provider_specific_fields"] = (
+                            provider_specific_fields_by_index[i]
+                        )
+
+                    # Only append to partial_response_tool_calls if it's empty
+                    if len(self.partial_response_tool_calls) == 0:
+                        self.partial_response_tool_calls.append(tool_call_dict)
+
+                self.partial_response_function_call = (
+                    response.choices[0].message.tool_calls[0].function
+                )
+        except AttributeError as e:
+            func_err = e
+
+        try:
+            reasoning_content = response.choices[0].message.reasoning_content
+        except AttributeError:
+            try:
+                reasoning_content = response.choices[0].message.reasoning
+            except AttributeError:
+                reasoning_content = None
+
+        self.partial_response_reasoning_content = reasoning_content or ""
+
+        try:
+            self.partial_response_content = response.choices[0].message.content or ""
+        except AttributeError as e:
+            content_err = e
+
+        return response, func_err, content_err
+
     def stream_wrapper(self, content, final):
         if not hasattr(self, "_streaming_buffer_length"):
             self._streaming_buffer_length = 0
@@ -3233,12 +3433,21 @@ class Coder:
             return
 
     def get_all_relative_files(self):
-        staged_files_hash = hash(str([item.a_path for item in self.repo.repo.index.diff("HEAD")]))
-        if (
-            staged_files_hash == self.data_cache["repo"]["last_key"]
-            and self.data_cache["relative_files"]
-        ):
-            return self.data_cache["relative_files"]
+        if self.repo_map and self.repo:
+            try:
+                staged_files_hash = hash(
+                    str([item.a_path for item in self.repo.repo.index.diff("HEAD")])
+                )
+                if (
+                    staged_files_hash == self.data_cache["repo"]["last_key"]
+                    and self.data_cache["relative_files"]
+                ):
+                    return self.data_cache["relative_files"]
+            except ANY_GIT_ERROR as err:
+                # Handle git errors gracefully - fall back to getting tracked files
+                if self.verbose:
+                    self.io.tool_warning(f"Git error while checking staged files: {err}")
+                # Continue to get tracked files normally
 
         if self.repo:
             files = self.repo.get_tracked_files()
@@ -3388,6 +3597,16 @@ class Coder:
     async def apply_updates(self):
         edited = set()
         try:
+            if getattr(self.args, "tweak_responses", False):
+                confirmation = await self.io.confirm_ask("Tweak Response?", allow_tweak=True)
+
+                if confirmation or confirmation == "tweak":
+                    self.partial_response_content = self.io.edit_in_editor(
+                        self.partial_response_content
+                    )
+
+            await asyncio.sleep(0.1)
+
             edits = self.get_edits()
             edits = self.apply_edits_dry_run(edits)
             edits = await self.prepare_to_edit(edits)
@@ -3546,16 +3765,34 @@ class Coder:
     def apply_edits_dry_run(self, edits):
         return edits
 
-    def auto_save_session(self):
+    async def auto_save_session(self):
         """Automatically save the current session as 'auto-save'."""
         if not getattr(self.args, "auto_save", False):
             return
-        try:
-            session_manager = SessionManager(self, self.io)
-            session_manager.save_session("auto-save", False)
-        except Exception:
-            # Don't show errors for auto-save to avoid interrupting the user experience
-            pass
+
+        # Initialize last autosave time if not exists
+        if not hasattr(self, "_last_autosave_time"):
+            self._last_autosave_time = 0
+
+        if not hasattr(self, "_autosave_future"):
+            self._autosave_future = None
+
+        if self._autosave_future and not self._autosave_future.done():
+            return
+
+        # Throttle autosave to run at most once every 15 seconds
+        current_time = time.time()
+        if current_time - self._last_autosave_time >= 15.0:
+            try:
+                self._last_autosave_time = current_time
+                session_manager = SessionManager(self, self.io)
+                loop = asyncio.get_running_loop()
+                self._autosave_future = loop.run_in_executor(
+                    None, session_manager.save_session, "auto-save", False
+                )
+            except Exception:
+                # Don't show errors for auto-save to avoid interrupting the user experience
+                pass
 
     async def run_shell_commands(self):
         if not self.suggest_shell_commands:
@@ -3564,14 +3801,21 @@ class Coder:
         done = set()
         group = ConfirmGroup(set(self.shell_commands))
         accumulated_output = ""
-        for command in self.shell_commands:
-            if command in done:
-                continue
-            done.add(command)
-            output = await self.handle_shell_commands(command, group)
-            if output:
-                accumulated_output += output + "\n\n"
-        return accumulated_output
+
+        try:
+            self.commands.cmd_running = True
+
+            for command in self.shell_commands:
+                if command in done:
+                    continue
+                done.add(command)
+                output = await self.handle_shell_commands(command, group)
+                if output:
+                    accumulated_output += output + "\n\n"
+
+            return accumulated_output
+        finally:
+            self.commands.cmd_running = False
 
     async def handle_shell_commands(self, commands_str, group):
         commands = commands_str.strip().splitlines()
@@ -3594,6 +3838,10 @@ class Coder:
             if not command or command.startswith("#"):
                 continue
 
+            if command and getattr(self.args, "command_prefix", None):
+                command_prefix = getattr(self.args, "command_prefix", None)
+                command = f"{command_prefix} {command}"
+
             self.io.tool_output()
             self.io.tool_output(f"Running {command}")
             # Add the command to input history