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

aider/coders/base_prompts.py

@@ -77,11 +77,14 @@ The user is going to provide you with a conversation.
 This conversation is getting too long to fit in the context window of a language model.
 You need to summarize the conversation to reduce its length, while retaining all the important information.
 
-The summary should contain three parts:
+The summary should contain four parts:
 - Overall Goal: What is the user trying to achieve with this conversation?
 - Next Steps: What are the next steps for the language model to take to help the user?
-  Create a checklist of what has been done and what is left to do.
-- Active files: What files are currently in the context window?
+  Describe the current investigation path and intention.
+- Key Findings: Keep information most important to prevent having to search for it again
+  This should be quite specific (e/g. relevant files, method names, relevant lines of code, and code structure)
+- Active files: What files are currently most relevant to the discussion?
+  Be confident in proceeding with any in progress edits.
 
 Here is the conversation so far:
 """

aider/coders/chat_chunks.py

@@ -10,20 +10,34 @@ class ChatChunks:
     repo: List = field(default_factory=list)
     readonly_files: List = field(default_factory=list)
     chat_files: List = field(default_factory=list)
+    edit_files: List = field(default_factory=list)
     cur: List = field(default_factory=list)
     reminder: List = field(default_factory=list)
+    chunk_ordering: List = field(default_factory=list)
+
+    def __init__(self, chunk_ordering=None):
+        self.chunk_ordering = chunk_ordering
 
     def all_messages(self):
-        return (
-            self.system
-            + self.examples
-            + self.readonly_files
-            + self.repo
-            + self.done
-            + self.chat_files
-            + self.cur
-            + self.reminder
-        )
+        if self.chunk_ordering:
+            messages = []
+            for chunk_name in self.chunk_ordering:
+                chunk = getattr(self, chunk_name, [])
+                if chunk:
+                    messages.extend(chunk)
+            return messages
+        else:
+            return (
+                self.format_list(self.system)
+                + self.format_list(self.examples)
+                + self.format_list(self.readonly_files)
+                + self.format_list(self.chat_files)
+                + self.format_list(self.repo)
+                + self.format_list(self.done)
+                + self.format_list(self.edit_files)
+                + self.format_list(self.cur)
+                + self.format_list(self.reminder)
+            )
 
     def add_cache_control_headers(self):
         if self.examples:
@@ -31,15 +45,17 @@ class ChatChunks:
         else:
             self.add_cache_control(self.system)
 
-        if self.repo:
-            # this will mark both the readonly_files and repomap chunk as cacheable
-            self.add_cache_control(self.repo)
-        else:
-            # otherwise, just cache readonly_files if there are any
-            self.add_cache_control(self.readonly_files)
-
+        # The files form a cacheable block.
+        # The block starts with readonly_files and ends with chat_files.
+        # So we mark the end of chat_files.
         self.add_cache_control(self.chat_files)
 
+        # The repo map is its own cacheable block.
+        self.add_cache_control(self.repo)
+
+        # The history is ephemeral on its own.
+        self.add_cache_control(self.done)
+
     def add_cache_control(self, messages):
         if not messages:
             return
@@ -62,3 +78,9 @@ class ChatChunks:
             ):
                 return messages[: len(messages) - i]
         return messages
+
+    def format_list(self, chunk):
+        if type(chunk) is not list:
+            return []
+
+        return chunk

aider/commands.py

@@ -89,7 +89,8 @@ class Commands:
     async def cmd_model(self, args):
         "Switch the Main Model to a new LLM"
 
-        model_name = args.strip()
+        arg_split = args.split(" ", 1)
+        model_name = arg_split[0].strip()
         if not model_name:
             announcements = "\n".join(self.coder.get_announcements())
             self.io.tool_output(announcements)
@@ -111,19 +112,57 @@ class Commands:
             # If the user was using the old model's default, switch to the new model's default
             new_edit_format = model.edit_format
 
-        raise SwitchCoder(main_model=model, edit_format=new_edit_format)
+        if len(arg_split) > 1:
+            # implement architect coder-like generation call for model
+            message = arg_split[1].strip()
 
-    async def cmd_editor_model(self, args):
-        "Switch the Editor Model to a new LLM"
+            # Store the original model configuration
+            original_main_model = self.coder.main_model
+            original_edit_format = self.coder.edit_format
 
-        model_name = args.strip()
-        model = models.Model(
-            self.coder.main_model.name,
-            editor_model=model_name,
-            weak_model=self.coder.main_model.weak_model.name,
-        )
-        await models.sanity_check_models(self.io, model)
-        raise SwitchCoder(main_model=model)
+            # Create a temporary coder with the new model
+            from aider.coders import Coder
+
+            kwargs = dict()
+            kwargs["main_model"] = model
+            kwargs["edit_format"] = new_edit_format
+            kwargs["suggest_shell_commands"] = False
+            kwargs["total_cost"] = self.coder.total_cost
+            kwargs["num_cache_warming_pings"] = 0
+            kwargs["summarize_from_coder"] = False
+
+            new_kwargs = dict(io=self.io, from_coder=self.coder)
+            new_kwargs.update(kwargs)
+
+            temp_coder = await Coder.create(**new_kwargs)
+            temp_coder.cur_messages = []
+            temp_coder.done_messages = []
+
+            if self.verbose:
+                temp_coder.show_announcements()
+
+            try:
+                await temp_coder.generate(user_message=message, preproc=False)
+                self.coder.move_back_cur_messages(
+                    f"Model {model_name} made those changes to the files."
+                )
+                self.coder.total_cost = temp_coder.total_cost
+                self.coder.aider_commit_hashes = temp_coder.aider_commit_hashes
+
+                # Restore the original model configuration
+                raise SwitchCoder(main_model=original_main_model, edit_format=original_edit_format)
+            except Exception as e:
+                # If there's an error, still restore the original model
+                if not isinstance(e, SwitchCoder):
+                    self.io.tool_error(e)
+                    raise SwitchCoder(
+                        main_model=original_main_model, edit_format=original_edit_format
+                    )
+                else:
+                    # Re-raise SwitchCoder if that's what was thrown
+                    raise
+        else:
+            raise SwitchCoder(main_model=model, edit_format=new_edit_format)
 
     async def cmd_weak_model(self, args):
         "Switch the Weak Model to a new LLM"
@@ -414,7 +453,6 @@ class Commands:
                 )
 
             lint_coder.add_rel_fname(fname)
-            await self.coder.io.recreate_input()
             await lint_coder.run_one(errors, preproc=False)
             lint_coder.abs_fnames = set()
 
@@ -999,6 +1037,22 @@ class Commands:
                         if hasattr(self.coder, "_calculate_context_block_tokens"):
                             self.coder._calculate_context_block_tokens()
 
+        if self.coder.repo_map:
+            map_tokens = self.coder.repo_map.max_map_tokens
+            map_mul_no_files = self.coder.repo_map.map_mul_no_files
+        else:
+            map_tokens = 0
+            map_mul_no_files = 1
+
+        raise SwitchCoder(
+            edit_format=self.coder.edit_format,
+            summarize_from_coder=False,
+            from_coder=self.coder,
+            map_tokens=map_tokens,
+            map_mul_no_files=map_mul_no_files,
+            show_announcements=False,
+        )
+
     def completions_drop(self):
         files = self.coder.get_inchat_relative_files()
         read_only_files = [
@@ -1095,7 +1149,7 @@ class Commands:
                     matched_files = [
                         self.coder.get_rel_fname(f)
                         for f in self.coder.abs_fnames
-                        if expanded_word in f
+                        if self.coder.abs_root_path(expanded_word) in f
                     ]
 
                 if not matched_files:
@@ -1498,6 +1552,9 @@ class Commands:
 
         from aider.coders.base_coder import Coder
 
+        original_main_model = self.coder.main_model
+        original_edit_format = self.coder.edit_format
+
         coder = await Coder.create(
             io=self.io,
             from_coder=self.coder,
@@ -1508,9 +1565,16 @@ class Commands:
         )
 
         user_msg = args
-        await coder.run(user_msg, False)
+        await coder.generate(user_message=user_msg, preproc=False)
         self.coder.aider_commit_hashes = coder.aider_commit_hashes
 
+        raise SwitchCoder(
+            main_model=original_main_model,
+            edit_format=original_edit_format,
+            done_messages=coder.done_messages,
+            cur_messages=coder.cur_messages,
+        )
+
     def get_help_md(self):
         "Show help about all commands in markdown"
 

aider/diffs.py

@@ -63,17 +63,18 @@ def diff_partial_update(lines_orig, lines_updated, final=False, fname=None):
     if last_non_deleted is None:
         return ""
 
-    if num_orig_lines:
-        pct = last_non_deleted * 100 / num_orig_lines
-    else:
-        pct = 50
-    bar = create_progress_bar(pct)
-    bar = f" {last_non_deleted:3d} / {num_orig_lines:3d} lines [{bar}] {pct:3.0f}%\n"
+    # if num_orig_lines:
+    #     pct = last_non_deleted * 100 / num_orig_lines
+    # else:
+    #     pct = 50
+    # bar = create_progress_bar(pct)
+    # bar = f" {last_non_deleted:3d} / {num_orig_lines:3d} lines [{bar}] {pct:3.0f}%\n"
 
     lines_orig = lines_orig[:last_non_deleted]
 
     if not final:
-        lines_updated = lines_updated[:-1] + [bar]
+        # lines_updated = lines_updated[:-1] + [bar]
+        lines_updated = lines_updated[:-1]
 
     diff = difflib.unified_diff(lines_orig, lines_updated, n=5)
 
@@ -88,14 +89,14 @@ def diff_partial_update(lines_orig, lines_updated, final=False, fname=None):
         if backticks not in diff:
             break
 
-    show = f"{backticks}diff\n"
+    show = "diff\n"
     if fname:
         show += f"--- {fname} original\n"
         show += f"+++ {fname} updated\n"
 
     show += diff
 
-    show += f"{backticks}\n\n"
+    show += "\n\n"
 
     # print(diff)
 

aider/exceptions.py

@@ -20,7 +20,7 @@ EXCEPTIONS = [
         "The API provider is not able to authenticate you. Check your API key.",
     ),
     ExInfo("AzureOpenAIError", True, None),
-    ExInfo("BadGatewayError", False, None),
+    ExInfo("BadGatewayError", True, None),
     ExInfo("BadRequestError", False, None),
     ExInfo("BudgetExceededError", True, None),
     ExInfo(

aider/helpers/coroutines.py

@@ -0,0 +1,8 @@
+import asyncio  # noqa: F401
+
+
+def is_active(coroutine):
+    if not coroutine or coroutine.done() or coroutine.cancelled():
+        return False
+
+    return True

aider/helpers/requests.py

@@ -0,0 +1,45 @@
+from ..sendchat import ensure_alternating_roles
+
+
+def thought_signature(model, messages):
+    # Add thought signatures for Vertex AI and Gemini models
+    if model.name.startswith("vertex_ai/") or model.name.startswith("gemini/"):
+        for msg in messages:
+            if "tool_calls" in msg:
+                tool_calls = msg["tool_calls"]
+
+                if tool_calls:
+                    for call in tool_calls:
+                        if not call:
+                            continue
+
+                        # Check if thought signature is missing in extra_content.google.thought_signature
+                        if "provider_specific_fields" not in call:
+                            call["provider_specific_fields"] = {}
+                        if "thought_signature" not in call["provider_specific_fields"]:
+                            call["provider_specific_fields"][
+                                "thought_signature"
+                            ] = "skip_thought_signature_validator"
+
+            if "function_call" in msg:
+                call = msg["function_call"]
+
+                if not call:
+                    continue
+
+                # Check if thought signature is missing in extra_content.google.thought_signature
+                if "provider_specific_fields" not in call:
+                    call["provider_specific_fields"] = {}
+                if "thought_signature" not in call["provider_specific_fields"]:
+                    call["provider_specific_fields"][
+                        "thought_signature"
+                    ] = "skip_thought_signature_validator"
+
+    return messages
+
+
+def model_request_parser(model, messages):
+    messages = thought_signature(model, messages)
+    messages = ensure_alternating_roles(messages)
+
+    return messages

aider/history.py

@@ -30,6 +30,11 @@ class ChatSummary:
             sized.append((tokens, msg))
         return sized
 
+    def count_tokens(self, messages):
+        sized = self.tokenize(messages)
+        total = sum(tokens for tokens, _msg in sized)
+        return total
+
     async def summarize(self, messages, depth=0):
         messages = await self.summarize_real(messages)
         if messages and messages[-1]["role"] != "assistant":