V0.91.3

.github/workflows/ubuntu-tests.yml

@@ -50,6 +50,7 @@ jobs:
         uv pip install --system \
           pytest \
           pytest-asyncio \
+          pytest-mock \
           -r requirements/requirements.in \
           -r requirements/requirements-help.in \
           -r requirements/requirements-playwright.in \

.github/workflows/windows-tests.yml

@@ -42,11 +42,10 @@ jobs:
       run: |
         python -m pip install --upgrade pip
         pip install uv
-        uv pip install --system pytest pytest-asyncio -r requirements/requirements.in -r requirements/requirements-help.in -r requirements/requirements-playwright.in '.[help,playwright]'
+        uv pip install --system pytest pytest-asyncio pytest-mock -r requirements/requirements.in -r requirements/requirements-help.in -r requirements/requirements-playwright.in '.[help,playwright]'
 
     - name: Run tests
       env:
         AIDER_ANALYTICS: false
       run: |
         pytest
-

aider/__init__.py

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

aider/args.py

@@ -838,6 +838,7 @@ def get_parser(default_config_files, git_root):
     )
     group.add_argument(
         "--yes-always",
+        "--yes",
         action="store_true",
         help="Always say yes to every confirmation (not including cli commands)",
         default=None,

aider/coders/agent_coder.py

@@ -369,23 +369,26 @@ def get_local_tool_schemas(self):
     async def initialize_mcp_tools(self):
         await super().initialize_mcp_tools()
 
-        local_tools = self.get_local_tool_schemas()
-        if not local_tools:
-            return
+        server_name = "Local"
+
+        if server_name not in [name for name, _ in self.mcp_tools]:
+            local_tools = self.get_local_tool_schemas()
+            if not local_tools:
+                return
 
-        local_server_config = {"name": "Local"}
-        local_server = LocalServer(local_server_config)
+            local_server_config = {"name": server_name}
+            local_server = LocalServer(local_server_config)
 
-        if not self.mcp_servers:
-            self.mcp_servers = []
-        if not any(isinstance(s, LocalServer) for s in self.mcp_servers):
-            self.mcp_servers.append(local_server)
+            if not self.mcp_servers:
+                self.mcp_servers = []
+            if not any(isinstance(s, LocalServer) for s in self.mcp_servers):
+                self.mcp_servers.append(local_server)
 
-        if not self.mcp_tools:
-            self.mcp_tools = []
+            if not self.mcp_tools:
+                self.mcp_tools = []
 
-        if "local_tools" not in [name for name, _ in self.mcp_tools]:
-            self.mcp_tools.append((local_server.name, local_tools))
+            if server_name not in [name for name, _ in self.mcp_tools]:
+                self.mcp_tools.append((local_server.name, local_tools))
 
     async def _execute_local_tool_calls(self, tool_calls_list):
         tool_responses = []

aider/coders/architect_coder.py

@@ -41,14 +41,6 @@ async def reply_completed(self):
         kwargs["cache_prompts"] = False
         kwargs["num_cache_warming_pings"] = 0
         kwargs["summarize_from_coder"] = False
-        kwargs["mcp_servers"] = []  # Empty to skip initialization
-
-        coder = await Coder.create(**kwargs)
-        # Transfer MCP state to avoid re-initialization
-        coder.mcp_servers = self.mcp_servers
-        coder.mcp_tools = self.mcp_tools
-        # Transfer TUI app weak reference
-        coder.tui = self.tui
 
         new_kwargs = dict(io=self.io, from_coder=self)
         new_kwargs.update(kwargs)

aider/coders/base_coder.py

@@ -233,22 +233,32 @@ async def create(
             kwargs = use_kwargs
             from_coder.ok_to_warm_cache = False
 
+        res = None
         if (
             getattr(main_model, "copy_paste_mode", False)
             and getattr(main_model, "copy_paste_transport", "api") == "clipboard"
         ):
             res = coders.CopyPasteCoder(main_model, io, args=args, **kwargs)
+
+        if not res:
+            for coder in coders.__all__:
+                if hasattr(coder, "edit_format") and coder.edit_format == edit_format:
+                    res = coder(main_model, io, args=args, **kwargs)
+
+        if res is not None:
+            if from_coder:
+                if from_coder.mcp_servers and kwargs.get("mcp_servers", False):
+                    res.mcp_servers = from_coder.mcp_servers
+                    res.mcp_tools = from_coder.mcp_tools
+
+                # Transfer TUI app weak reference
+                res.tui = from_coder.tui
+
             await res.initialize_mcp_tools()
+
             res.original_kwargs = dict(kwargs)
             return res
 
-        for coder in coders.__all__:
-            if hasattr(coder, "edit_format") and coder.edit_format == edit_format:
-                res = coder(main_model, io, args=args, **kwargs)
-                await res.initialize_mcp_tools()
-                res.original_kwargs = dict(kwargs)
-                return res
-
         valid_formats = [
             str(c.edit_format)
             for c in coders.__all__
@@ -2703,6 +2713,12 @@ async def initialize_mcp_tools(self):
         tools = []
 
         async def get_server_tools(server):
+            # Check if we already have tools for this server in mcp_tools
+            if self.mcp_tools:
+                for server_name, server_tools in self.mcp_tools:
+                    if server_name == server.name:
+                        return (server.name, server_tools)
+
             try:
                 session = await server.connect()
                 server_tools = await experimental_mcp_client.load_mcp_tools(
@@ -3266,8 +3282,20 @@ def consolidate_chunks(self):
         self.partial_response_reasoning_content = reasoning_content or ""
 
         try:
-            if not self.partial_response_reasoning_content:
-                self.partial_response_content = response.choices[0].message.content or ""
+            content = response.choices[0].message.content
+            if isinstance(content, list):
+                # OpenAI-compatible APIs sometimes return content as a list
+                # of blocks; join the textual pieces for display.
+                content = "".join(
+                    block.get("text", "")
+                    for block in content
+                    if isinstance(block, dict) and block.get("type") == "output_text"
+                ) or "".join(
+                    block.get("text", "")
+                    for block in content
+                    if isinstance(block, dict) and block.get("type") == "text"
+                )
+            self.partial_response_content = content or ""
         except AttributeError as e:
             content_err = e
 

aider/commands/help.py

@@ -52,14 +52,8 @@ async def execute(cls, io, coder, args, **kwargs):
         kwargs["suggest_shell_commands"] = False
         kwargs["cache_prompts"] = False
         kwargs["num_cache_warming_pings"] = 0
-        kwargs["mcp_servers"] = []  # Empty to skip initialization
 
         help_coder = await Coder.create(**kwargs)
-        # Transfer MCP state to avoid re-initialization
-        help_coder.mcp_servers = coder.mcp_servers
-        help_coder.mcp_tools = coder.mcp_tools
-        # Transfer TUI app weak reference
-        help_coder.tui = coder.tui
         user_msg = help_instance.ask(args)
         user_msg += """
 # Announcement lines from when this session of aider was launched:

aider/commands/lint.py

@@ -2,6 +2,7 @@
 
 from aider.commands.utils.base_command import BaseCommand
 from aider.commands.utils.helpers import format_command_result
+from aider.utils import expand_glob_patterns
 
 
 class LintCommand(BaseCommand):
@@ -11,7 +12,16 @@ class LintCommand(BaseCommand):
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
         """Execute the lint command with given parameters."""
-        fnames = kwargs.get("fnames", None)
+        fnames = None
+
+        # Get files from CLI arguments if available
+        system_args = kwargs.get("system_args")
+        if system_args:
+            cli_files = getattr(system_args, "files", []) or []
+            cli_file_arg = getattr(system_args, "file", []) or []
+            all_cli_files = cli_files + cli_file_arg
+            if all_cli_files:
+                fnames = expand_glob_patterns(all_cli_files)
 
         if not coder.repo:
             io.tool_error("No git repository found.")
@@ -21,7 +31,7 @@ async def execute(cls, io, coder, args, **kwargs):
             fnames = coder.get_inchat_relative_files()
 
         # If still no files, get all dirty files in the repo
-        if not fnames and coder.repo:
+        if not fnames:
             fnames = coder.repo.get_dirty_files()
 
         if not fnames:

aider/commands/model.py

@@ -94,10 +94,7 @@ async def execute(cls, io, coder, args, **kwargs):
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:
         """Get completion options for model command."""
-        from aider.llm import litellm
-
-        model_names = litellm.model_cost.keys()
-        return list(model_names)
+        return models.get_chat_model_names()
 
     @classmethod
     def get_help(cls) -> str:

aider/commands/models.py

@@ -24,10 +24,7 @@ async def execute(cls, io, coder, args, **kwargs):
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:
         """Get completion options for models command."""
-        from aider.llm import litellm
-
-        model_names = litellm.model_cost.keys()
-        return list(model_names)
+        return models.get_chat_model_names()
 
     @classmethod
     def get_help(cls) -> str:

aider/commands/read_only.py

@@ -207,9 +207,43 @@ def _add_read_only_directory(
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:
         """Get completion options for read-only command."""
-        # For read-only command, we could return file paths for completion
-        # For now, return empty list - the completion system will handle path completion
-        return []
+        from pathlib import Path
+
+        root = Path(coder.root) if hasattr(coder, "root") else Path.cwd()
+
+        # Handle the prefix - could be partial path like "src/ma" or just "ma"
+        if "/" in args:
+            # Has directory component
+            dir_part, file_part = args.rsplit("/", 1)
+            search_dir = root / dir_part
+            search_prefix = file_part.lower()
+            path_prefix = dir_part + "/"
+        else:
+            search_dir = root
+            search_prefix = args.lower()
+            path_prefix = ""
+
+        completions = []
+        try:
+            if search_dir.exists() and search_dir.is_dir():
+                for entry in search_dir.iterdir():
+                    name = entry.name
+                    if search_prefix and search_prefix not in name.lower():
+                        continue
+                    # Add trailing slash for directories
+                    if entry.is_dir():
+                        completions.append(path_prefix + name + "/")
+                    else:
+                        completions.append(path_prefix + name)
+        except (PermissionError, OSError):
+            pass
+
+        add_completions = coder.commands.get_completions("/add")
+        for c in add_completions:
+            if args.lower() in str(c).lower() and str(c) not in completions:
+                completions.append(str(c))
+
+        return sorted(completions)
 
     @classmethod
     def get_help(cls) -> str:

aider/commands/read_only_stub.py

@@ -206,10 +206,44 @@ def _add_read_only_directory(
 
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:
-        """Get completion options for read-only-stub command."""
-        # For read-only-stub command, we could return file paths for completion
-        # For now, return empty list - the completion system will handle path completion
-        return []
+        """Get completion options for read-only command."""
+        from pathlib import Path
+
+        root = Path(coder.root) if hasattr(coder, "root") else Path.cwd()
+
+        # Handle the prefix - could be partial path like "src/ma" or just "ma"
+        if "/" in args:
+            # Has directory component
+            dir_part, file_part = args.rsplit("/", 1)
+            search_dir = root / dir_part
+            search_prefix = file_part.lower()
+            path_prefix = dir_part + "/"
+        else:
+            search_dir = root
+            search_prefix = args.lower()
+            path_prefix = ""
+
+        completions = []
+        try:
+            if search_dir.exists() and search_dir.is_dir():
+                for entry in search_dir.iterdir():
+                    name = entry.name
+                    if search_prefix and search_prefix not in name.lower():
+                        continue
+                    # Add trailing slash for directories
+                    if entry.is_dir():
+                        completions.append(path_prefix + name + "/")
+                    else:
+                        completions.append(path_prefix + name)
+        except (PermissionError, OSError):
+            pass
+
+        add_completions = coder.commands.get_completions("/add")
+        for c in add_completions:
+            if args.lower() in str(c).lower() and str(c) not in completions:
+                completions.append(str(c))
+
+        return sorted(completions)
 
     @classmethod
     def get_help(cls) -> str:

aider/commands/utils/base_command.py

@@ -116,14 +116,7 @@ async def _generic_chat_command(cls, io, coder, args, edit_format, placeholder=N
             "args": coder.args,
         }
 
-        kwargs["mcp_servers"] = []  # Empty to skip initialization
-
         new_coder = await Coder.create(**kwargs)
-        # Transfer MCP state to avoid re-initialization
-        new_coder.mcp_servers = coder.mcp_servers
-        new_coder.mcp_tools = coder.mcp_tools
-        # Transfer TUI app weak reference
-        new_coder.tui = coder.tui
 
         await new_coder.generate(user_message=user_msg, preproc=False)
         coder.aider_commit_hashes = new_coder.aider_commit_hashes