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

aider/coders/agent_coder.py

@@ -20,6 +20,13 @@ from aider import urls, utils
 
 # Import the change tracker
 from aider.change_tracker import ChangeTracker
+
+# Import similarity functions for tool usage analysis
+from aider.helpers.similarity import (
+    cosine_similarity,
+    create_bigram_vector,
+    normalize_vector,
+)
 from aider.mcp.server import LocalServer
 from aider.repo import ANY_GIT_ERROR
 
@@ -52,6 +59,7 @@ from aider.tools import (
     replace_lines,
     replace_text,
     show_numbered_context,
+    thinking,
     undo_change,
     update_todo_list,
     view,
@@ -78,8 +86,15 @@ class AgentCoder(Coder):
         self.recently_removed = {}
 
         # Tool usage history
-        self.tool_usage_history = []
+        self.tool_usage_history = []  # Stores lists of tools used in each round
         self.tool_usage_retries = 10
+        self.last_round_tools = []  # Tools used in the current round
+
+        # Similarity tracking for tool usage
+        self.tool_call_vectors = []  # Store vectors for individual tool calls
+        self.tool_similarity_threshold = 0.99  # High threshold for exact matches
+        self.max_tool_vector_history = 10  # Keep history of 10 rounds
+
         self.read_tools = {
             "viewfilesatglob",
             "viewfilesmatching",
@@ -101,7 +116,7 @@ class AgentCoder(Coder):
         }
 
         # Configuration parameters
-        self.max_tool_calls = 100  # Maximum number of tool calls per response
+        self.max_tool_calls = 10000  # Maximum number of tool calls per response
 
         # Context management parameters
         # Will be overridden by agent_config if provided
@@ -117,7 +132,7 @@ class AgentCoder(Coder):
 
         # Initialize tool registry
         self.args = kwargs.get("args")
-        self._tool_registry = self._build_tool_registry()
+        self.tool_registry = self._build_tool_registry()
 
         # Track files added during current exploration
         self.files_added_in_exploration = set()
@@ -132,14 +147,20 @@ class AgentCoder(Coder):
         # Enable enhanced context blocks by default
         self.use_enhanced_context = True
 
+        # Caching efficiency attributes
+        self._last_edited_file = None
+        self._cur_message_divider = None
+
         # Initialize empty token tracking dictionary and cache structures
         # but don't populate yet to avoid startup delay
+        self.allowed_context_blocks = set()
         self.context_block_tokens = {}
         self.context_blocks_cache = {}
         self.tokens_calculated = False
 
         self.skip_cli_confirmations = False
 
+        self.agent_finished = False
         self._get_agent_config()
         super().__init__(*args, **kwargs)
 
@@ -181,6 +202,7 @@ class AgentCoder(Coder):
             replace_lines,
             replace_text,
             show_numbered_context,
+            thinking,
             undo_change,
             update_todo_list,
             view,
@@ -200,8 +222,9 @@ class AgentCoder(Coder):
         # Always include essential tools regardless of includelist/excludelist
         essential_tools = {"makeeditable", "replacetext", "view", "finished"}
         for module in tool_modules:
-            if hasattr(module, "NORM_NAME") and hasattr(module, "process_response"):
-                tool_name = module.NORM_NAME
+            if hasattr(module, "Tool"):
+                tool_class = module.Tool
+                tool_name = tool_class.NORM_NAME
 
                 # Check if tool should be included based on configuration
                 should_include = True
@@ -219,7 +242,7 @@ class AgentCoder(Coder):
                     should_include = False
 
                 if should_include:
-                    registry[tool_name] = module
+                    registry[tool_name] = tool_class
 
         return registry
 
@@ -253,6 +276,25 @@ class AgentCoder(Coder):
         if "tools_excludelist" not in config:
             config["tools_excludelist"] = []
 
+        if "include_context_blocks" in config:
+            self.allowed_context_blocks = set(config["context_blocks"])
+        else:
+            self.allowed_context_blocks = {
+                "context_summary",
+                "directory_structure",
+                "environment_info",
+                "git_status",
+                "symbol_outline",
+                "todo_list",
+            }
+
+        if "exclude_context_blocks" in config:
+            for context_block in config["exclude_context_blocks"]:
+                try:
+                    self.allowed_context_blocks.remove(context_block)
+                except KeyError:
+                    pass
+
         # Apply configuration to instance
         self.large_file_token_threshold = config["large_file_token_threshold"]
         self.skip_cli_confirmations = config.get(
@@ -266,9 +308,9 @@ class AgentCoder(Coder):
         schemas = []
 
         # Get schemas from the tool registry
-        for tool_module in self._tool_registry.values():
-            if hasattr(tool_module, "schema"):
-                schemas.append(tool_module.schema)
+        for tool_module in self.tool_registry.values():
+            if hasattr(tool_module, "SCHEMA"):
+                schemas.append(tool_module.SCHEMA)
 
         return schemas
 
@@ -323,8 +365,8 @@ class AgentCoder(Coder):
                 tasks = []
 
                 # Use the tool registry for execution
-                if norm_tool_name in self._tool_registry:
-                    tool_module = self._tool_registry[norm_tool_name]
+                if norm_tool_name in self.tool_registry:
+                    tool_module = self.tool_registry[norm_tool_name]
                     for params in parsed_args_list:
                         # Use the process_response function from the tool module
                         result = tool_module.process_response(self, params)
@@ -464,11 +506,12 @@ class AgentCoder(Coder):
             ]
 
             for block_type in block_types:
-                block_content = self._generate_context_block(block_type)
-                if block_content:
-                    self.context_block_tokens[block_type] = self.main_model.token_count(
-                        block_content
-                    )
+                if block_type in self.allowed_context_blocks:
+                    block_content = self._generate_context_block(block_type)
+                    if block_content:
+                        self.context_block_tokens[block_type] = self.main_model.token_count(
+                            block_content
+                        )
 
             # Mark as calculated
             self.tokens_calculated = True
@@ -651,7 +694,19 @@ class AgentCoder(Coder):
         if self.gpt_prompts.system_reminder:
             main_sys += "\n" + self.fmt_system_prompt(self.gpt_prompts.system_reminder)
 
-        chunks = ChatChunks()
+        chunks = ChatChunks(
+            chunk_ordering=[
+                "system",
+                "examples",
+                "readonly_files",
+                "repo",
+                "chat_files",
+                "done",
+                "edit_files",
+                "cur",
+                "reminder",
+            ]
+        )
 
         if self.main_model.use_system_prompt:
             chunks.system = [
@@ -666,11 +721,40 @@ class AgentCoder(Coder):
         chunks.examples = example_messages
 
         self.summarize_end()
-        chunks.done = list(self.done_messages)
+        cur_messages_list = list(self.cur_messages)
+        cur_messages_pre = []
+        cur_messages_post = cur_messages_list
+        chunks.readonly_files = self.get_readonly_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", [])
+        edit_file_names = chat_files_result.get("edit_file_names", set())
+
+        # Update edit file tracking for caching efficiency
+        divider = self._update_edit_file_tracking(edit_file_names)
+        if divider is not None:
+            # Split cur_messages using the divider
+            if divider > 0 and divider < len(cur_messages_list):
+                cur_messages_pre = cur_messages_list[:divider]
+                cur_messages_post = cur_messages_list[divider:]
 
         chunks.repo = self.get_repo_messages()
-        chunks.readonly_files = self.get_readonly_files_messages()
-        chunks.chat_files = self.get_chat_files_messages()
+        chunks.done = list(self.done_messages) + cur_messages_pre
+
+        # Add reminder if needed
+        if self.gpt_prompts.system_reminder:
+            reminder_message = [
+                dict(
+                    role="system", content=self.fmt_system_prompt(self.gpt_prompts.system_reminder)
+                ),
+            ]
+        else:
+            reminder_message = []
+
+        chunks.cur = cur_messages_post
+        chunks.reminder = []
 
         # Make sure token counts are updated - using centralized method
         # This also populates the context block cache
@@ -689,53 +773,46 @@ class AgentCoder(Coder):
         # 1. Add relatively static blocks BEFORE done_messages
         # These blocks change less frequently and can be part of the cacheable prefix
         static_blocks = []
-        if dir_structure:
-            static_blocks.append(dir_structure)
-        if env_context:
+        if env_context and "environment_info" in self.allowed_context_blocks:
             static_blocks.append(env_context)
+        if dir_structure and "directory_structure" in self.allowed_context_blocks:
+            static_blocks.append(dir_structure)
 
         if static_blocks:
             static_message = "\n\n".join(static_blocks)
             # Insert as a system message right before done_messages
-            chunks.done.insert(0, dict(role="system", content=static_message))
+            chunks.system.append(dict(role="system", content=static_message))
 
         # 2. Add dynamic blocks AFTER chat_files
         # These blocks change with the current files in context
-        dynamic_blocks = []
-        if todo_list:
-            dynamic_blocks.append(todo_list)
-        if context_summary:
-            dynamic_blocks.append(context_summary)
-        if symbol_outline:
-            dynamic_blocks.append(symbol_outline)
-        if git_status:
-            dynamic_blocks.append(git_status)
-
+        pre_dynamic_blocks = []
+        post_dynamic_blocks = []
+        if context_summary and "context_summary" in self.allowed_context_blocks:
+            pre_dynamic_blocks.append(context_summary)
+        if symbol_outline and "symbol_outline" in self.allowed_context_blocks:
+            pre_dynamic_blocks.append(symbol_outline)
+        if git_status and "git_status" in self.allowed_context_blocks:
+            pre_dynamic_blocks.append(git_status)
+
+        if todo_list and "todo_list" in self.allowed_context_blocks:
+            pre_dynamic_blocks.append(todo_list)
         # Add tool usage context if there are repetitive tools
         if hasattr(self, "tool_usage_history") and self.tool_usage_history:
             repetitive_tools = self._get_repetitive_tools()
             if repetitive_tools:
                 tool_context = self._generate_tool_context(repetitive_tools)
                 if tool_context:
-                    dynamic_blocks.append(tool_context)
+                    pre_dynamic_blocks.append(tool_context)
 
-        if dynamic_blocks:
-            dynamic_message = "\n\n".join(dynamic_blocks)
-            # Append as a system message after chat_files
-            chunks.chat_files.append(dict(role="system", content=dynamic_message))
+        if pre_dynamic_blocks:
+            dynamic_message = "\n\n".join(pre_dynamic_blocks)
+            # Append as a system message on reminders
+            chunks.done.insert(0, dict(role="system", content=dynamic_message))
 
-        # Add reminder if needed
-        if self.gpt_prompts.system_reminder:
-            reminder_message = [
-                dict(
-                    role="system", content=self.fmt_system_prompt(self.gpt_prompts.system_reminder)
-                ),
-            ]
-        else:
-            reminder_message = []
-
-        chunks.cur = list(self.cur_messages)
-        chunks.reminder = []
+        if post_dynamic_blocks:
+            dynamic_message = "\n\n".join(post_dynamic_blocks)
+            # Append as a system message on reminders
+            reminder_message.insert(0, dict(role="system", content=dynamic_message))
 
         # Use accurate token counting method that considers enhanced context blocks
         base_messages = chunks.all_messages()
@@ -780,6 +857,37 @@ class AgentCoder(Coder):
 
         return chunks
 
+    def _update_edit_file_tracking(self, edit_file_names):
+        """
+        Update tracking for last edited file and message divider for caching efficiency.
+
+        When the last edited file changes, we store the current message index minus 4
+        as a divider to split cur_messages, moving older messages to done_messages
+        for better caching.
+        """
+        kept_messages = 8
+        if not edit_file_names:
+            self._cur_message_divider = 0
+
+        # Get the most recently edited file from the edit_file_names set
+        # We assume the first file in the sorted set is the most recent
+        sorted_edit_files = sorted(edit_file_names)
+        current_edited_file = sorted_edit_files[0] if sorted_edit_files else None
+
+        # Check if the last edited file has changed
+        if current_edited_file != self._last_edited_file:
+            # Store the new last edited file
+            self._last_edited_file = current_edited_file
+
+            # Calculate divider: current index minus last n messages
+            cur_messages_list = list(self.cur_messages)
+            if len(cur_messages_list) > kept_messages:
+                self._cur_message_divider = len(cur_messages_list) - kept_messages
+            else:
+                self._cur_message_divider = 0
+
+        return self._cur_message_divider
+
     def get_context_summary(self):
         """
         Generate a summary of the current context, including file content tokens and additional context blocks,
@@ -944,15 +1052,40 @@ class AgentCoder(Coder):
         """
         Track tool usage before calling the base implementation.
         """
-        self.auto_save_session()
+        self.agent_finished = False
+        await self.auto_save_session()
+
+        # Clear last round tools and start tracking new round
+        self.last_round_tools = []
 
         if self.partial_response_tool_calls:
             for tool_call in self.partial_response_tool_calls:
-                self.tool_usage_history.append(tool_call.get("function", {}).get("name"))
+                tool_name = tool_call.get("function", {}).get("name")
+
+                if tool_name:
+                    self.last_round_tools.append(tool_name)
+
+                    # Create and store vector for this tool call
+                    # Remove id property if present before stringifying
+                    tool_call_copy = tool_call.copy()
+                    if "id" in tool_call_copy:
+                        del tool_call_copy["id"]
+                    tool_call_str = str(tool_call_copy)  # Convert entire tool call to string
+                    tool_vector = create_bigram_vector((tool_call_str,))
+                    tool_vector_norm = normalize_vector(tool_vector)
+                    self.tool_call_vectors.append(tool_vector_norm)
+
+        # Add the completed round to history
+        if self.last_round_tools:
+            self.tool_usage_history += self.last_round_tools
+            self.tool_usage_history = list(filter(None, self.tool_usage_history))
 
         if len(self.tool_usage_history) > self.tool_usage_retries:
             self.tool_usage_history.pop(0)
 
+        if len(self.tool_call_vectors) > self.max_tool_vector_history:
+            self.tool_call_vectors.pop(0)
+
         return await super().process_tool_calls(tool_call_response)
 
     async def reply_completed(self):
@@ -968,7 +1101,6 @@ class AgentCoder(Coder):
         a final answer to the user's question.
         """
         # Legacy tool call processing for use_granular_editing=False
-        self.agent_finished = False
         content = self.partial_response_content
         if not content or not content.strip():
             if len(self.tool_usage_history) > self.tool_usage_retries:
@@ -1136,8 +1268,8 @@ class AgentCoder(Coder):
             str: Result message
         """
         # Check if tool exists in registry
-        if norm_tool_name in self._tool_registry:
-            tool_module = self._tool_registry[norm_tool_name]
+        if norm_tool_name in self.tool_registry:
+            tool_module = self.tool_registry[norm_tool_name]
             try:
                 # Use the process_response function from the tool module
                 result = tool_module.process_response(self, params)
@@ -1163,6 +1295,73 @@ class AgentCoder(Coder):
 
         return f"Error: Unknown tool name '{norm_tool_name}'"
 
+    def _convert_concatenated_json_to_tool_calls(self, content):
+        """
+        Check if content contains concatenated JSON objects and convert them to tool call format.
+
+        Args:
+            content (str): Content to check for concatenated JSON
+
+        Returns:
+            str: Content with concatenated JSON converted to tool call format, or original content if no JSON found
+        """
+        try:
+            # Use split_concatenated_json to detect and split concatenated JSON objects
+            json_chunks = utils.split_concatenated_json(content)
+
+            # If we found multiple JSON objects, convert them to tool call format
+            if len(json_chunks) >= 1:
+                tool_calls = []
+                for chunk in json_chunks:
+                    try:
+                        json_obj = json.loads(chunk)
+                        # Check if this looks like a tool call JSON object
+                        if (
+                            isinstance(json_obj, dict)
+                            and "name" in json_obj
+                            and "arguments" in json_obj
+                        ):
+                            tool_name = json_obj["name"]
+                            arguments = json_obj["arguments"]
+
+                            # Convert arguments dictionary to keyword arguments string
+                            kw_args = []
+                            for key, value in arguments.items():
+                                if isinstance(value, str):
+                                    # Escape quotes and wrap in quotes
+                                    escaped_value = value.replace('"', '\\"')
+                                    kw_args.append(f'{key}="{escaped_value}"')
+                                elif isinstance(value, bool):
+                                    kw_args.append(f"{key}={str(value).lower()}")
+                                elif value is None:
+                                    kw_args.append(f"{key}=None")
+                                else:
+                                    # For numbers and other types, use repr for safe representation
+                                    kw_args.append(f"{key}={repr(value)}")
+
+                            # Join keyword arguments
+                            kw_args_str = ", ".join(kw_args)
+
+                            # Convert to [tool_call(ToolName, key1="value1", key2="value2")] format
+                            tool_call = f"[tool_call({tool_name}, {kw_args_str})]"
+                            tool_calls.append(tool_call)
+                        else:
+                            # Not a tool call JSON, keep as is
+                            tool_calls.append(chunk)
+                    except json.JSONDecodeError:
+                        # Invalid JSON, keep as is
+                        tool_calls.append(chunk)
+
+                # If we found any tool calls, replace the content
+                if any(call.startswith("[tool_") for call in tool_calls):
+                    return "".join(tool_calls)
+
+        except Exception as e:
+            # If anything goes wrong, return original content
+            self.io.tool_warning(f"Error converting concatenated JSON to tool calls: {str(e)}")
+
+        return content
+
     async def _process_tool_commands(self, content):
         """
         Process tool commands in the `[tool_call(name, param=value)]` format within the content.
@@ -1182,20 +1381,31 @@ class AgentCoder(Coder):
         max_calls = self.max_tool_calls
         tool_names = []
 
+        # Check if content contains concatenated JSON and convert to tool call format
+        content = self._convert_concatenated_json_to_tool_calls(content)
+
         # Check if there's a '---' separator and only process tool calls after the LAST one
         separator_marker = "---"
         content_parts = content.split(separator_marker)
 
         # If there's no separator, treat the entire content as before the separator
+        # But only return immediately if no tool calls were found in the JSON conversion
         if len(content_parts) == 1:
-            # Return the original content with no tool calls processed, and the content itself as before_separator
-            return content, result_messages, False, content, tool_names
+            # Check if we have any tool calls in the content after JSON conversion
+            # If we have tool calls, we should process them even without a separator
+            tool_call_pattern = r"\[tool_call\([^\]]+\)\]"
+            if re.search(tool_call_pattern, content):
+                # We have tool calls, so continue processing
+                content_before_separator = ""
+                content_after_separator = content
+            else:
+                # No tool calls found, return the original content
+                return content, result_messages, False, content, tool_names
 
         # Take everything before the last separator (including intermediate separators)
         content_before_separator = separator_marker.join(content_parts[:-1])
         # Take only what comes after the last separator
         content_after_separator = content_parts[-1]
-
         # Find tool calls using a more robust method, but only in the content after separator
         processed_content = content_before_separator + separator_marker
         last_index = 0
@@ -1492,13 +1702,14 @@ class AgentCoder(Coder):
 
     def _get_repetitive_tools(self):
         """
-        Identifies repetitive tool usage patterns from a flat list of tool calls.
+        Identifies repetitive tool usage patterns from rounds of tool calls.
 
-        This method checks for the following patterns in order:
-        1. If the last tool used was a write tool, it assumes progress and returns no repetitive tools.
-        2. It checks for any read tool that has been used 2 or more times in the history.
+        This method combines count-based and similarity-based detection:
+        1. If the last round contained a write tool, it assumes progress and returns no repetitive tools.
+        2. It checks for any read tool that has been used 2 or more times across rounds.
         3. If no tools are repeated, but all tools in the history are read tools,
            it flags all of them as potentially repetitive.
+        4. It checks for similarity-based repetition using cosine similarity on tool call strings.
 
         It avoids flagging repetition if a "write" tool was used recently,
         as that suggests progress is being made.
@@ -1509,31 +1720,71 @@ class AgentCoder(Coder):
         if history_len < 2:
             return set()
 
-        # If the last tool was a write tool, we're likely making progress.
-        if isinstance(self.tool_usage_history[-1], str):
-            last_tool_lower = self.tool_usage_history[-1].lower()
+        # Check for similarity-based repetition
+        similarity_repetitive_tools = self._get_repetitive_tools_by_similarity()
+
+        # Flatten the tool usage history for count-based analysis
+        all_tools = []
+        for round_tools in self.tool_usage_history:
+            all_tools.extend(round_tools)
 
-            if last_tool_lower in self.write_tools:
+        # If the last round contained a write tool, we're likely making progress.
+        if self.last_round_tools:
+            last_round_has_write = any(
+                tool.lower() in self.write_tools for tool in self.last_round_tools
+            )
+            if last_round_has_write:
                 self.tool_usage_history = []
-                return set()
+                return similarity_repetitive_tools if len(similarity_repetitive_tools) else set()
 
         # If all tools in history are read tools, return all of them
-        if all(tool.lower() in self.read_tools for tool in self.tool_usage_history):
-            return set(tool for tool in self.tool_usage_history)
+        if all(tool.lower() in self.read_tools for tool in all_tools):
+            return set(all_tools)
 
-        # Check for any read tool used more than once
-        tool_counts = Counter(tool for tool in self.tool_usage_history)
-        repetitive_tools = {
+        # Check for any read tool used more than once across rounds
+        tool_counts = Counter(all_tools)
+        count_repetitive_tools = {
             tool
             for tool, count in tool_counts.items()
             if count >= 2 and tool.lower() in self.read_tools
         }
 
+        # Combine both detection methods
+        repetitive_tools = count_repetitive_tools.union(similarity_repetitive_tools)
+
         if repetitive_tools:
             return repetitive_tools
 
         return set()
 
+    def _get_repetitive_tools_by_similarity(self):
+        """
+        Identifies repetitive tool usage patterns using cosine similarity on tool call strings.
+
+        This method checks if the latest tool calls are highly similar (>0.99 threshold)
+        to historical tool calls using bigram vector similarity.
+
+        Returns:
+            set: Set of tool names that are repetitive based on similarity
+        """
+        if not self.tool_usage_history or len(self.tool_call_vectors) < 2:
+            return set()
+
+        # Get the latest tool call vector
+        latest_vector = self.tool_call_vectors[-1]
+
+        # Check similarity against historical vectors (excluding the latest)
+        for i, historical_vector in enumerate(self.tool_call_vectors[:-1]):
+            similarity = cosine_similarity(latest_vector, historical_vector)
+
+            # If similarity is high enough, flag as repetitive
+            if similarity >= self.tool_similarity_threshold:
+                # Return the tool name from the corresponding position in history
+                if i < len(self.tool_usage_history):
+                    return {self.tool_usage_history[i]}
+
+        return set()
+
     def _generate_tool_context(self, repetitive_tools):
         """
         Generate a context message for the LLM about recent tool usage.
@@ -1546,8 +1797,7 @@ class AgentCoder(Coder):
         # Add turn and tool call statistics
         context_parts.append("## Turn and Tool Call Statistics")
         context_parts.append(f"- Current turn: {self.num_reflections + 1}")
-        context_parts.append(f"- Tool calls this turn: {self.tool_call_count}")
-        context_parts.append(f"- Total tool calls in session: {self.num_tool_calls}")
+        context_parts.append(f"- Total tool calls this turn: {self.num_tool_calls}")
         context_parts.append("\n\n")
 
         # Add recent tool usage history
@@ -1572,7 +1822,9 @@ class AgentCoder(Coder):
             for tool in repetitive_tools:
                 context_parts.append(f"- `{tool}`")
             context_parts.append(
-                "Your exploration appears to be stuck in a loop. Please try a different approach:"
+                "Your exploration appears to be stuck in a loop. Please try a different approach."
+                " Use the `Thinking` tool to clarify your intentions and new approach to"
+                " what you are currently attempting to accomplish."
             )
             context_parts.append("\n")
             context_parts.append("**Suggestions for alternative approaches:**")
@@ -1914,7 +2166,7 @@ Just reply with fixed versions of the {blocks} above that failed to match.
                         if line.startswith("??"):
                             # Extract the filename (remove the '?? ' prefix)
                             untracked_file = line[3:]
-                            if not self.repo.git_ignored_file(untracked_file):
+                            if not self.repo.ignored_file(untracked_file):
                                 untracked_files.append(untracked_file)
                 except Exception as e:
                     self.io.tool_warning(f"Error getting untracked files: {str(e)}")
@@ -2000,7 +2252,7 @@ Just reply with fixed versions of the {blocks} above that failed to match.
             if not os.path.isfile(abs_path):
                 return (
                     '<context name="todo_list">\n'
-                    "Todo list does not exist. Please update it."
+                    "Todo list does not exist. Please update it with the `UpdataTodoList` tool."
                     "</context>"
                 )
 
@@ -2012,7 +2264,7 @@ Just reply with fixed versions of the {blocks} above that failed to match.
             # Format the todo list context block
             result = '<context name="todo_list">\n'
             result += "## Current Todo List\n\n"
-            result += "Below is the current todo list managed via `UpdateTodoList` tool:\n\n"
+            result += "Below is the current todo list managed via the `UpdateTodoList` tool:\n\n"
             result += f"```\n{content}\n```\n"
             result += "</context>"