aider-ce 0.87.13.dev3__py3-none-any.whl → 0.88.1__py3-none-any.whl

aider/llm.py

@@ -20,8 +20,20 @@ VERBOSE = False
 
 class LazyLiteLLM:
     _lazy_module = None
+    _lazy_classes = {
+        "ModelResponse": "ModelResponse",
+        "Choices": "Choices",
+        "Message": "Message",
+    }
 
     def __getattr__(self, name):
+        # Check if the requested attribute is one of the explicitly lazy-loaded classes
+        if name in self._lazy_classes:
+            self._load_litellm()
+            class_name = self._lazy_classes[name]
+            return getattr(self._lazy_module, class_name)
+
+        # Handle other attributes (like `acompletion`) as before
         if name == "_lazy_module":
             return super()
         self._load_litellm()
@@ -31,11 +43,7 @@ class LazyLiteLLM:
         if self._lazy_module is not None:
             return
 
-        if VERBOSE:
-            print("Loading litellm...")
-
         self._lazy_module = importlib.import_module("litellm")
-
         self._lazy_module.suppress_debug_info = True
         self._lazy_module.set_verbose = False
         self._lazy_module.drop_params = True

aider/main.py

@@ -1,3 +1,4 @@
+import asyncio
 import glob
 import json
 import os
@@ -411,7 +412,7 @@ def register_litellm_models(git_root, model_metadata_fname, io, verbose=False):
         return 1
 
 
-def sanity_check_repo(repo, io):
+async def sanity_check_repo(repo, io):
     if not repo:
         return True
 
@@ -442,7 +443,7 @@ def sanity_check_repo(repo, io):
         io.tool_error("Aider only works with git repos with version number 1 or 2.")
         io.tool_output("You may be able to convert your repo: git update-index --index-version=2")
         io.tool_output("Or run aider --no-git to proceed without using git.")
-        io.offer_url(urls.git_index_version, "Open documentation url for more info?")
+        await io.offer_url(urls.git_index_version, "Open documentation url for more info?")
         return False
 
     io.tool_error("Unable to read git repository, it may be corrupt?")
@@ -470,6 +471,10 @@ def expand_glob_patterns(patterns, root="."):
 
 
 def main(argv=None, input=None, output=None, force_git_root=None, return_coder=False):
+    return asyncio.run(main_async(argv, input, output, force_git_root, return_coder))
+
+
+async def main_async(argv=None, input=None, output=None, force_git_root=None, return_coder=False):
     report_uncaught_exceptions()
 
     if argv is None:
@@ -744,7 +749,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         right_repo_root = guessed_wrong_repo(io, git_root, fnames, git_dname)
         if right_repo_root:
             analytics.event("exit", reason="Recursing with correct repo")
-            return main(argv, input, output, right_repo_root, return_coder=return_coder)
+            return await main_async(argv, input, output, right_repo_root, return_coder=return_coder)
 
     if args.just_check_update:
         update_available = check_version(io, just_check=True, verbose=args.verbose)
@@ -778,7 +783,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
     io.tool_output(cmd_line, log_only=True)
 
     is_first_run = is_first_run_of_new_version(io, verbose=args.verbose)
-    check_and_load_imports(io, is_first_run, verbose=args.verbose)
+    await check_and_load_imports(io, is_first_run, verbose=args.verbose)
 
     register_models(git_root, args.model_settings_file, io, verbose=args.verbose)
     register_litellm_models(git_root, args.model_metadata_file, io, verbose=args.verbose)
@@ -801,7 +806,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
             alias, model = parts
             models.MODEL_ALIASES[alias.strip()] = model.strip()
 
-    selected_model_name = select_default_model(args, io, analytics)
+    selected_model_name = await select_default_model(args, io, analytics)
     if not selected_model_name:
         # Error message and analytics event are handled within select_default_model
         # It might have already offered OAuth if no model/keys were found.
@@ -816,7 +821,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
             " found."
         )
         # Attempt OAuth flow because the specific model needs it
-        if offer_openrouter_oauth(io, analytics):
+        if await offer_openrouter_oauth(io, analytics):
             # OAuth succeeded, the key should now be in os.environ.
             # Check if the key is now present after the flow.
             if os.environ.get("OPENROUTER_API_KEY"):
@@ -839,7 +844,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
             io.tool_error(
                 f"Unable to proceed without an OpenRouter API key for model '{args.model}'."
             )
-            io.offer_url(urls.models_and_keys, "Open documentation URL for more info?")
+            await io.offer_url(urls.models_and_keys, "Open documentation URL for more info?")
             analytics.event(
                 "exit",
                 reason="OpenRouter key missing for specified model and OAuth failed/declined",
@@ -921,7 +926,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
             io.tool_output("You can skip this check with --no-show-model-warnings")
 
             try:
-                io.offer_url(urls.model_warnings, "Open documentation url for more info?")
+                await io.offer_url(urls.model_warnings, "Open documentation url for more info?")
                 io.tool_output()
             except KeyboardInterrupt:
                 analytics.event("exit", reason="Keyboard interrupt during model warnings")
@@ -949,7 +954,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
             pass
 
     if not args.skip_sanity_check_repo:
-        if not sanity_check_repo(repo, io):
+        if not await sanity_check_repo(repo, io):
             analytics.event("exit", reason="Repository sanity check failed")
             return 1
 
@@ -1010,7 +1015,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         if not mcp_servers:
             mcp_servers = []
 
-        coder = Coder.create(
+        coder = await Coder.create(
             main_model=main_model,
             edit_format=args.edit_format,
             io=io,
@@ -1054,7 +1059,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         )
     except UnknownEditFormat as err:
         io.tool_error(str(err))
-        io.offer_url(urls.edit_formats, "Open documentation about edit formats?")
+        await io.offer_url(urls.edit_formats, "Open documentation about edit formats?")
         analytics.event("exit", reason="Unknown edit format")
         return 1
     except ValueError as err:
@@ -1086,8 +1091,6 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         analytics.event("copy-paste mode")
         ClipboardWatcher(coder.io, verbose=args.verbose)
 
-    coder.show_announcements()
-
     if args.show_prompts:
         coder.cur_messages += [
             dict(role="user", content="Hello!"),
@@ -1098,22 +1101,22 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         return
 
     if args.lint:
-        coder.commands.cmd_lint(fnames=fnames)
+        await coder.commands.cmd_lint(fnames=fnames)
 
     if args.test:
         if not args.test_cmd:
             io.tool_error("No --test-cmd provided.")
             analytics.event("exit", reason="No test command provided")
             return 1
-        coder.commands.cmd_test(args.test_cmd)
+        await coder.commands.cmd_test(args.test_cmd)
         if io.placeholder:
-            coder.run(io.placeholder)
+            await coder.run(io.placeholder)
 
     if args.commit:
         if args.dry_run:
             io.tool_output("Dry run enabled, skipping commit.")
         else:
-            coder.commands.cmd_commit()
+            await coder.commands.cmd_commit()
 
     if args.lint or args.test or args.commit:
         analytics.event("exit", reason="Completed lint/test/commit")
@@ -1135,7 +1138,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         # For testing #2879
         # from aider.coders.base_coder import all_fences
         # coder.fence = all_fences[1]
-        coder.apply_updates()
+        await coder.apply_updates()
         analytics.event("exit", reason="Applied updates")
         return
 
@@ -1149,7 +1152,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         webbrowser.open(urls.release_notes)
     elif args.show_release_notes is None and is_first_run:
         io.tool_output()
-        io.offer_url(
+        await io.offer_url(
             urls.release_notes,
             "Would you like to see what's new in this version?",
             allow_never=False,
@@ -1168,14 +1171,14 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         io.tool_warning("Cost estimates may be inaccurate when using streaming and caching.")
 
     if args.load:
-        commands.cmd_load(args.load)
+        await commands.cmd_load(args.load)
 
     if args.message:
         io.add_to_input_history(args.message)
         io.tool_output()
         try:
-            coder.run(with_message=args.message)
-        except SwitchCoder:
+            await coder.run(with_message=args.message)
+        except (SwitchCoder, KeyboardInterrupt):
             pass
         analytics.event("exit", reason="Completed --message")
         return
@@ -1184,7 +1187,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
         try:
             message_from_file = io.read_text(args.message_file)
             io.tool_output()
-            coder.run(with_message=message_from_file)
+            await coder.run(with_message=message_from_file)
         except FileNotFoundError:
             io.tool_error(f"Message file not found: {args.message_file}")
             analytics.event("exit", reason="Message file not found")
@@ -1206,7 +1209,7 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
     while True:
         try:
             coder.ok_to_warm_cache = bool(args.cache_keepalive_pings)
-            coder.run()
+            await coder.run()
             analytics.event("exit", reason="Completed main CLI coder.run")
             return
         except SwitchCoder as switch:
@@ -1224,10 +1227,10 @@ def main(argv=None, input=None, output=None, force_git_root=None, return_coder=F
             # Disable cache warming for the new coder
             kwargs["num_cache_warming_pings"] = 0
 
-            coder = Coder.create(**kwargs)
+            coder = await Coder.create(**kwargs)
 
-            if switch.kwargs.get("show_announcements") is not False:
-                coder.show_announcements()
+            if switch.kwargs.get("show_announcements") is False:
+                coder.suppress_announcements_for_next_prompt = True
 
 
 def is_first_run_of_new_version(io, verbose=False):
@@ -1273,7 +1276,7 @@ def is_first_run_of_new_version(io, verbose=False):
         return True  # Safer to assume it's a first run if we hit an error
 
 
-def check_and_load_imports(io, is_first_run, verbose=False):
+async def check_and_load_imports(io, is_first_run, verbose=False):
     try:
         if is_first_run:
             if verbose:
@@ -1285,7 +1288,7 @@ def check_and_load_imports(io, is_first_run, verbose=False):
             except Exception as err:
                 io.tool_error(str(err))
                 io.tool_output("Error loading required imports. Did you install aider properly?")
-                io.offer_url(urls.install_properly, "Open documentation url for more info?")
+                await io.offer_url(urls.install_properly, "Open documentation url for more info?")
                 sys.exit(1)
 
             if verbose:

aider/mcp/__init__.py

@@ -1,6 +1,7 @@
 import json
+from pathlib import Path
 
-from aider.mcp.server import HttpStreamingServer, McpServer
+from aider.mcp.server import HttpStreamingServer, McpServer, SseServer
 
 
 def _parse_mcp_servers_from_json_string(json_string, io, verbose=False, mcp_transport="stdio"):
@@ -24,6 +25,8 @@ def _parse_mcp_servers_from_json_string(json_string, io, verbose=False, mcp_tran
                     servers.append(McpServer(server_config))
                 elif transport == "http":
                     servers.append(HttpStreamingServer(server_config))
+                elif transport == "sse":
+                    servers.append(SseServer(server_config))
 
             if verbose:
                 io.tool_output(f"Loaded {len(servers)} MCP servers from JSON string")
@@ -38,12 +41,72 @@ def _parse_mcp_servers_from_json_string(json_string, io, verbose=False, mcp_tran
     return servers
 
 
+def _resolve_mcp_config_path(file_path, io, verbose=False):
+    """Resolve MCP config file path relative to closest aider.conf.yml, git directory, or CWD."""
+    if not file_path:
+        return None
+
+    # If the path is absolute or already exists, use it as-is
+    path = Path(file_path)
+    if path.is_absolute() or path.exists():
+        return str(path.resolve())
+
+    # Search for the closest aider.conf.yml in parent directories
+    current_dir = Path.cwd()
+    aider_conf_path = None
+
+    for parent in [current_dir] + list(current_dir.parents):
+        conf_file = parent / ".aider.conf.yml"
+        if conf_file.exists():
+            aider_conf_path = parent
+            break
+
+    # If aider.conf.yml found, try relative to that directory
+    if aider_conf_path:
+        resolved_path = aider_conf_path / file_path
+        if resolved_path.exists():
+            if verbose:
+                io.tool_output(f"Resolved MCP config relative to aider.conf.yml: {resolved_path}")
+            return str(resolved_path.resolve())
+
+    # Try to find git root directory
+    git_root = None
+    try:
+        import git
+
+        repo = git.Repo(search_parent_directories=True)
+        git_root = Path(repo.working_tree_dir)
+    except (ImportError, git.InvalidGitRepositoryError, FileNotFoundError):
+        pass
+
+    # If git root found, try relative to that directory
+    if git_root:
+        resolved_path = git_root / file_path
+        if resolved_path.exists():
+            if verbose:
+                io.tool_output(f"Resolved MCP config relative to git root: {resolved_path}")
+            return str(resolved_path.resolve())
+
+    # Finally, try relative to current working directory
+    resolved_path = current_dir / file_path
+    if resolved_path.exists():
+        if verbose:
+            io.tool_output(f"Resolved MCP config relative to CWD: {resolved_path}")
+        return str(resolved_path.resolve())
+
+    # If none found, return the original path (will trigger FileNotFoundError)
+    return str(path.resolve())
+
+
 def _parse_mcp_servers_from_file(file_path, io, verbose=False, mcp_transport="stdio"):
     """Parse MCP servers from a JSON file."""
     servers = []
 
+    # Resolve the file path relative to closest aider.conf.yml, git directory, or CWD
+    resolved_file_path = _resolve_mcp_config_path(file_path, io, verbose)
+
     try:
-        with open(file_path, "r") as f:
+        with open(resolved_file_path, "r") as f:
             config = json.load(f)
 
         if verbose:

aider/mcp/server.py

@@ -4,6 +4,7 @@ import os
 from contextlib import AsyncExitStack
 
 from mcp import ClientSession, StdioServerParameters
+from mcp.client.sse import sse_client
 from mcp.client.stdio import stdio_client
 from mcp.client.streamable_http import streamablehttp_client
 
@@ -13,12 +14,7 @@ class McpServer:
     A client for MCP servers that provides tools to Aider coders. An McpServer class
     is initialized per configured MCP Server
 
-    Current usage:
-
-        conn = await session.connect()  # Use connect() directly
-        tools = await experimental_mcp_client.load_mcp_tools(session=s, format="openai")
-        await session.disconnect()
-        print(tools)
+    Uses the mcp library to create and initialize ClientSession objects.
     """
 
     def __init__(self, server_config):
@@ -72,21 +68,25 @@ class McpServer:
             try:
                 await self.exit_stack.aclose()
                 self.session = None
-                self.stdio_context = None
             except Exception as e:
                 logging.error(f"Error during cleanup of server {self.name}: {e}")
 
 
 class HttpStreamingServer(McpServer):
+    """HTTP streaming MCP server using mcp.client.streamablehttp_client."""
+
     async def connect(self):
         if self.session is not None:
             logging.info(f"Using existing session for MCP server: {self.name}")
             return self.session
 
-        logging.info(f"Establishing new connection to MCP server: {self.name}")
+        logging.info(f"Establishing new connection to HTTP MCP server: {self.name}")
         try:
-            url = self.config["url"]
-            http_transport = await self.exit_stack.enter_async_context(streamablehttp_client(url))
+            url = self.config.get("url")
+            headers = self.config.get("headers", {})
+            http_transport = await self.exit_stack.enter_async_context(
+                streamablehttp_client(url, headers=headers)
+            )
             read, write, _response = http_transport
 
             session = await self.exit_stack.enter_async_context(ClientSession(read, write))
@@ -94,7 +94,33 @@ class HttpStreamingServer(McpServer):
             self.session = session
             return session
         except Exception as e:
-            logging.error(f"Error initializing server {self.name}: {e}")
+            logging.error(f"Error initializing HTTP server {self.name}: {e}")
+            await self.disconnect()
+            raise
+
+
+class SseServer(McpServer):
+    """SSE (Server-Sent Events) MCP server using mcp.client.sse_client."""
+
+    async def connect(self):
+        if self.session is not None:
+            logging.info(f"Using existing session for SSE MCP server: {self.name}")
+            return self.session
+
+        logging.info(f"Establishing new connection to SSE MCP server: {self.name}")
+        try:
+            url = self.config.get("url")
+            headers = self.config.get("headers", {})
+            sse_transport = await self.exit_stack.enter_async_context(
+                sse_client(url, headers=headers)
+            )
+            read, write, _response = sse_transport
+            session = await self.exit_stack.enter_async_context(ClientSession(read, write))
+            await session.initialize()
+            self.session = session
+            return session
+        except Exception as e:
+            logging.error(f"Error initializing SSE server {self.name}: {e}")
             await self.disconnect()
             raise
 

aider/models.py

@@ -1,3 +1,4 @@
+import asyncio
 import difflib
 import hashlib
 import importlib.resources
@@ -893,23 +894,33 @@ class Model(ModelSettings):
                 return self.extra_params["extra_body"]["reasoning_effort"]
         return None
 
-    def is_deepseek_r1(self):
+    def is_deepseek(self):
         name = self.name.lower()
         if "deepseek" not in name:
             return
-        return "r1" in name or "reasoner" in name
+        return True
 
     def is_ollama(self):
         return self.name.startswith("ollama/") or self.name.startswith("ollama_chat/")
 
-    def send_completion(
+    async def send_completion(
         self, messages, functions, stream, temperature=None, tools=None, max_tokens=None
     ):
         if os.environ.get("AIDER_SANITY_CHECK_TURNS"):
             sanity_check_messages(messages)
 
-        if self.is_deepseek_r1():
-            messages = ensure_alternating_roles(messages)
+        messages = ensure_alternating_roles(messages)
+
+        if self.verbose:
+            for message in messages:
+                msg_role = message.get("role")
+                msg_content = message.get("content") if message.get("content") else ""
+                msg_trunc = ""
+
+                if message.get("content"):
+                    msg_trunc = message.get("content")[:30]
+
+                print(f"{msg_role} ({len(msg_content)}): {msg_trunc}")
 
         kwargs = dict(model=self.name, stream=stream)
 
@@ -923,26 +934,22 @@ class Model(ModelSettings):
             kwargs["temperature"] = temperature
 
         # `tools` is for modern tool usage. `functions` is for legacy/forced calls.
-        # If `tools` is provided, it's the canonical list. If not, use `functions`.
         # This handles `base_coder` sending both with same content for `navigator_coder`.
-        effective_tools = tools if tools is not None else functions
+        effective_tools = tools
+
+        if effective_tools is None and functions:
+            # Convert legacy `functions` to `tools` format if `tools` isn't provided.
+            effective_tools = [dict(type="function", function=f) for f in functions]
 
         if effective_tools:
-            # Check if we have legacy format functions (which lack a 'type' key) and convert them.
-            # This is a simplifying assumption that works for aider's use cases.
-            is_legacy = any("type" not in tool for tool in effective_tools)
-            if is_legacy:
-                kwargs["tools"] = [dict(type="function", function=tool) for tool in effective_tools]
-            else:
-                kwargs["tools"] = effective_tools
+            kwargs["tools"] = effective_tools
 
         # Forcing a function call is for legacy style `functions` with a single function.
         # This is used by ArchitectCoder and not intended for NavigatorCoder's tools.
         if functions and len(functions) == 1:
             function = functions[0]
-            is_legacy = "type" not in function
 
-            if is_legacy and "name" in function:
+            if "name" in function:
                 tool_name = function.get("name")
                 if tool_name:
                     kwargs["tool_choice"] = {"type": "function", "function": {"name": tool_name}}
@@ -978,16 +985,18 @@ class Model(ModelSettings):
                 }
 
         try:
-            res = litellm.completion(**kwargs)
+            res = await litellm.acompletion(**kwargs)
         except Exception as err:
-            res = "Model API Response Error. Please retry the previous request"
+            print(f"LiteLLM API Error: {str(err)}")
+            res = self.model_error_response()
 
             if self.verbose:
                 print(f"LiteLLM API Error: {str(err)}")
+                raise
 
         return hash_object, res
 
-    def simple_send_with_retries(self, messages, max_tokens=None):
+    async def simple_send_with_retries(self, messages, max_tokens=None):
         from aider.exceptions import LiteLLMExceptions
 
         litellm_ex = LiteLLMExceptions()
@@ -1000,7 +1009,7 @@ class Model(ModelSettings):
 
         while True:
             try:
-                _hash, response = self.send_completion(
+                _hash, response = await self.send_completion(
                     messages=messages,
                     functions=None,
                     stream=False,
@@ -1031,6 +1040,22 @@ class Model(ModelSettings):
             except AttributeError:
                 return None
 
+    async def model_error_response(self):
+        for i in range(1):
+            await asyncio.sleep(0.1)
+            yield litellm.ModelResponse(
+                choices=[
+                    litellm.Choices(
+                        finish_reason="stop",
+                        index=0,
+                        message=litellm.Message(
+                            content="Model API Response Error. Please retry the previous request"
+                        ),  # Provide an empty message object
+                    )
+                ],
+                model=self.name,
+            )
+
 
 def register_models(model_settings_fnames):
     files_loaded = []

aider/onboarding.py

@@ -76,7 +76,7 @@ def try_to_select_default_model():
     return None
 
 
-def offer_openrouter_oauth(io, analytics):
+async def offer_openrouter_oauth(io, analytics):
     """
     Offers OpenRouter OAuth flow to the user if no API keys are found.
 
@@ -90,7 +90,7 @@ def offer_openrouter_oauth(io, analytics):
     # No API keys found - Offer OpenRouter OAuth
     io.tool_output("OpenRouter provides free and paid access to many LLMs.")
     # Use confirm_ask which handles non-interactive cases
-    if io.confirm_ask(
+    if await io.confirm_ask(
         "Login to OpenRouter or create a free account?",
         default="y",
     ):
@@ -113,7 +113,7 @@ def offer_openrouter_oauth(io, analytics):
     return False
 
 
-def select_default_model(args, io, analytics):
+async def select_default_model(args, io, analytics):
     """
     Selects a default model based on available API keys if no model is specified.
     Offers OAuth flow for OpenRouter if no keys are found.
@@ -139,14 +139,14 @@ def select_default_model(args, io, analytics):
     io.tool_warning(no_model_msg)
 
     # Try OAuth if no model was detected
-    offer_openrouter_oauth(io, analytics)
+    await offer_openrouter_oauth(io, analytics)
 
     # Check again after potential OAuth success
     model = try_to_select_default_model()
     if model:
         return model
 
-    io.offer_url(urls.models_and_keys, "Open documentation URL for more info?")
+    await io.offer_url(urls.models_and_keys, "Open documentation URL for more info?")
 
 
 # Helper function to find an available port

aider/repo.py

@@ -21,7 +21,7 @@ import pathspec
 from aider import prompts, utils
 
 from .dump import dump  # noqa: F401
-from .waiting import WaitingSpinner
+from .waiting import Spinner
 
 ANY_GIT_ERROR += [
     OSError,
@@ -128,7 +128,7 @@ class GitRepo:
         if aider_ignore_file:
             self.aider_ignore_file = Path(aider_ignore_file)
 
-    def commit(self, fnames=None, context=None, message=None, aider_edits=False, coder=None):
+    async def commit(self, fnames=None, context=None, message=None, aider_edits=False, coder=None):
         """
         Commit the specified files or all dirty files if none are specified.
 
@@ -213,7 +213,7 @@ class GitRepo:
                 user_language = coder.commit_language
                 if not user_language:
                     user_language = coder.get_user_language()
-            commit_message = self.get_commit_message(diffs, context, user_language)
+            commit_message = await self.get_commit_message(diffs, context, user_language)
 
         # Retrieve attribute settings, prioritizing coder.args if available
         if coder and hasattr(coder, "args"):
@@ -323,7 +323,7 @@ class GitRepo:
         except (ValueError, OSError):
             return self.repo.git_dir
 
-    def get_commit_message(self, diffs, context, user_language=None):
+    async def get_commit_message(self, diffs, context, user_language=None):
         diffs = "# Diffs:\n" + diffs
 
         content = ""
@@ -340,8 +340,8 @@ class GitRepo:
 
         commit_message = None
         for model in self.models:
-            spinner_text = f"Generating commit message with {model.name}"
-            with WaitingSpinner(spinner_text):
+            spinner_text = f"Generating commit message with {model.name}\n"
+            with Spinner(spinner_text):
                 if model.system_prompt_prefix:
                     current_system_content = model.system_prompt_prefix + "\n" + system_content
                 else:
@@ -358,7 +358,7 @@ class GitRepo:
                 if max_tokens and num_tokens > max_tokens:
                     continue
 
-                commit_message = model.simple_send_with_retries(messages)
+                commit_message = await model.simple_send_with_retries(messages)
                 if commit_message:
                     break  # Found a model that could generate the message