auto-coder 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

autocoder/agent/base_agentic/base_agent.py

@@ -14,7 +14,6 @@ import byzerllm
 from pydantic import BaseModel
 
 from autocoder.common import AutoCoderArgs, git_utils, SourceCodeList, SourceCode
-from autocoder.common.global_cancel import global_cancel
 from autocoder.rag.variable_holder import VariableHolder
 from autocoder.utils import llms as llms_utils
 from autocoder.common.global_cancel import global_cancel
@@ -22,13 +21,9 @@ from autocoder.common import detect_env
 from autocoder.common import shells
 from autocoder.common.printer import Printer
 from autocoder.utils.auto_project_type import ProjectTypeAnalyzer
-from autocoder.common.mcp_server import get_mcp_server, McpServerInfoRequest
+from autocoder.common.mcp_tools.server import get_mcp_server, McpServerInfoRequest
 from autocoder.common.file_monitor.monitor import FileMonitor
-from autocoder.common.rulefiles.autocoderrules_utils import get_required_and_index_rules
-from autocoder.auto_coder_runner import load_tokenizer
-from autocoder.linters.shadow_linter import ShadowLinter
-from autocoder.compilers.shadow_compiler import ShadowCompiler
-from autocoder.shadows.shadow_manager import ShadowManager
+from autocoder.common.rulefiles import get_required_and_index_rules, get_rules
 from autocoder.events.event_manager_singleton import get_event_manager
 from autocoder.events.event_types import Event, EventType, EventMetadata
 from autocoder.events import event_content as EventContentCreator
@@ -43,7 +38,8 @@ from .types import (
     BaseTool, ToolResult, AgentRequest, FileChangeEntry,
     LLMOutputEvent, LLMThinkingEvent, ToolCallEvent, ToolResultEvent, 
     CompletionEvent, ErrorEvent, TokenUsageEvent, AttemptCompletionTool,    
-    PlanModeRespondTool,Message,ReplyDecision, PlanModeRespondEvent
+    PlanModeRespondTool, Message, ReplyDecision, PlanModeRespondEvent, RetryEvent,
+    AgenticEditConversationConfig, ConversationAction
 )
 from .tool_registry import ToolRegistry
 from .tools.base_tool_resolver import BaseToolResolver
@@ -54,6 +50,19 @@ from .agentic_tool_display import get_tool_display_message
 from autocoder.common.utils_code_auto_generate import stream_chat_with_continue
 from autocoder.common.save_formatted_log import save_formatted_log
 from . import agentic_lang
+from autocoder.common.autocoderargs_parser import AutoCoderArgsParser
+import importlib.resources as resources
+
+def load_tokenizer():
+    from autocoder.rag.variable_holder import VariableHolder
+    from tokenizers import Tokenizer
+
+    try:
+        tokenizer_path = str(resources.files("autocoder") / "data" / "tokenizer.json")
+        VariableHolder.TOKENIZER_PATH = tokenizer_path
+        VariableHolder.TOKENIZER_MODEL = Tokenizer.from_file(tokenizer_path)
+    except FileNotFoundError:
+        tokenizer_path = None
 
 class BaseAgent(ABC):
     """
@@ -68,16 +77,29 @@ class BaseAgent(ABC):
         files: SourceCodeList,
         args: AutoCoderArgs,
         conversation_history: Optional[List[Dict[str, Any]]] = None,
-        default_tools_list: Optional[List[str]] = None
+        default_tools_list: Optional[List[str]] = None,
+        custom_system_prompt: Optional[str] = None,
+        conversation_config: Optional['AgenticEditConversationConfig'] = None,
+        cancel_token: Optional[str] = None
     ):
+        # 并行执行相关初始化
+        self._parallel_executor = None
+        if getattr(args, 'enable_parallel_tools', False):
+            from concurrent.futures import ThreadPoolExecutor
+            self._parallel_executor = ThreadPoolExecutor(max_workers=4)
         """
         初始化代理
 
         Args:
+            name: 代理名称
             llm: 语言模型客户端
             files: 源码文件列表
             args: 配置参数
             conversation_history: 对话历史记录
+            default_tools_list: 默认工具列表
+            custom_system_prompt: 自定义系统提示
+            conversation_config: 对话配置
+            cancel_token: 取消令牌
         """
         # 1. 初始化FileMonitor（必须最先进行）
         try:
@@ -102,7 +124,17 @@ class BaseAgent(ABC):
         self.args = args
         self.files = files
         self.printer = Printer()
-        self.conversation_history = conversation_history or []
+        # 对话历史存储优化：限制最大长度，实现LRU缓存
+        self.max_conversation_history = getattr(args, 'max_conversation_history', 20)
+        self.conversation_history = conversation_history[-self.max_conversation_history:] if conversation_history else []
+        self.conversation_config = conversation_config
+        self.cancel_token = cancel_token
+        
+        # 内存监控
+        self._memory_warning_issued = False
+        
+        # Initialize AutoCoderArgs parser for flexible parameter parsing
+        self.args_parser = AutoCoderArgsParser()
                
         
         # 5. 初始化其他组件
@@ -149,14 +181,25 @@ class BaseAgent(ABC):
         self.joined_groups: Dict[str, Group] = {}
         self.private_chats: Dict[str, List[Message]] = {}        
         self.agentic_conversations: List[Dict[str,Any]] = []
-        self.custom_system_prompt = "You are a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices."
+        self.custom_system_prompt = custom_system_prompt or "You are a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices."
         self.refuse_reply_reason = ""
         self._group_lock = threading.RLock()  # 保护 joined_groups
         self._chat_lock = threading.RLock()   # 保护 private_chats
         # 自动注册到AgentHub
         AgentHub.register_agent(self)
         register_default_tools(params=self._render_context(), default_tools_list=default_tools_list)
+
+    def _get_parsed_safe_zone_tokens(self) -> int:
+        """
+        解析 conversation_prune_safe_zone_tokens 参数，支持多种格式
         
+        Returns:
+            解析后的 token 数量
+        """
+        return self.args_parser.parse_conversation_prune_safe_zone_tokens(
+            self.args.conversation_prune_safe_zone_tokens,
+            self.args.code_model
+        )
 
     def who_am_i(self, role: str) -> 'BaseAgent':
         self.custom_system_prompt = role
@@ -393,41 +436,35 @@ class BaseAgent(ABC):
         """
         return self.file_changes
     
-    def _get_changed_files_from_shadow(self) -> List[str]:
+    def get_all_file_changes(self) -> Dict[str, FileChangeEntry]:
         """
-        获取影子系统当前有哪些文件被修改或新增。
+        获取当前记录的所有文件变更信息。
 
         Returns:
-            变更的文件路径列表
+            字典，key 为文件路径，value 为变更详情
         """
-        changed_files = []
-        shadow_root = self.shadow_manager.shadows_dir
-        for root, dirs, files in os.walk(shadow_root):
-            for fname in files:
-                shadow_file_path = os.path.join(root, fname)
-                try:
-                    project_file_path = self.shadow_manager.from_shadow_path(
-                        shadow_file_path)
-                    rel_path = os.path.relpath(
-                        project_file_path, self.args.source_dir)
-                    changed_files.append(rel_path)
-                except Exception:
-                    # 非映射关系，忽略
-                    continue
-        return changed_files
+        return self.file_changes    
     
     
+    # 缓存工具标签查找结果
+    _tool_tag_cache = {}
+
     def _reconstruct_tool_xml(self, tool: BaseTool) -> str:
         """
         Reconstructs the XML representation of a tool call from its Pydantic model.
         """
-        tool_tag = next(
-            (tag for tag, model in ToolRegistry.get_tag_model_map().items() if isinstance(tool, model)), None)
-        if not tool_tag:
-            logger.error(
-                f"Cannot find tag name for tool type {type(tool).__name__}")
-            # Return a placeholder or raise? Let's return an error XML string.
-            return f"<error>Could not find tag for tool {type(tool).__name__}</error>"
+        tool_type = type(tool)
+        # 首先检查缓存
+        tool_tag = self._tool_tag_cache.get(tool_type)
+        if tool_tag is None:
+            tool_tag = next(
+                (tag for tag, model in ToolRegistry.get_tag_model_map().items() if tool_type is model), None)
+            if tool_tag:
+                self._tool_tag_cache[tool_type] = tool_tag
+            else:
+                logger.error(
+                    f"Cannot find tag name for tool type {tool_type.__name__}")
+                return f"<error>Could not find tag for tool {tool_type.__name__}</error>"
 
         xml_parts = [f"<{tool_tag}>"]
         for field_name, field_value in tool.model_dump(exclude_none=True).items():
@@ -524,7 +561,7 @@ class BaseAgent(ABC):
         # Tool Use Guidelines
 
         1. In <thinking> tags, assess what information you already have and what information you need to proceed with the task.
-        2. Choose the most appropriate tool based on the task and the tool descriptions provided. Assess if you need additional information to proceed, and which of the available tools would be most effective for gathering this information. For example using the list_files tool is more effective than running a command like \`ls\` in the terminal. It's critical that you think about each available tool and use the one that best fits the current step in the task.
+        2. Choose the most appropriate tool based on the task and the tool descriptions provided. Assess if you need additional information to proceed, and which of the available tools would be most effective for gathering this information. For example using the list_files tool is more effective than running a command like `ls` in the terminal. It's critical that you think about each available tool and use the one that best fits the current step in the task.
         3. If multiple actions are needed, use one tool at a time per message to accomplish the task iteratively, with each tool use being informed by the result of the previous tool use. Do not assume the outcome of any tool use. Each step must be informed by the previous step's result.
         4. Formulate your tool use using the XML format specified for each tool.
         5. After each tool use, the user will respond with the result of that tool use. This result will provide you with the necessary information to continue your task or make further decisions. This response may include:
@@ -595,9 +632,9 @@ class BaseAgent(ABC):
         RULES
 
         - Your current working directory is: {{current_project}}
-        - You cannot \`cd\` into a different directory to complete a task. You are stuck operating from '{{ current_project }}', so be sure to pass in the correct 'path' parameter when using tools that require a path.
+        - You cannot `cd` into a different directory to complete a task. You are stuck operating from '{{ current_project }}', so be sure to pass in the correct 'path' parameter when using tools that require a path.
         - Do not use the ~ character or $HOME to refer to the home directory.
-        - Before using the execute_command tool, you must first think about the SYSTEM INFORMATION context provided to understand the user's environment and tailor your commands to ensure they are compatible with their system. You must also consider if the command you need to run should be executed in a specific directory outside of the current working directory '{{ current_project }}', and if so prepend with \`cd\`'ing into that directory && then executing the command (as one command since you are stuck operating from '{{current_project}}'). For example, if you needed to run \`npm install\` in a project outside of '{{current_project}}', you would need to prepend with a \`cd\` i.e. pseudocode for this would be \`cd (path to project) && (command, in this case npm install)\`.
+        - Before using the execute_command tool, you must first think about the SYSTEM INFORMATION context provided to understand the user's environment and tailor your commands to ensure they are compatible with their system. You must also consider if the command you need to run should be executed in a specific directory outside of the current working directory '{{ current_project }}', and if so prepend with `cd`'ing into that directory && then executing the command (as one command since you are stuck operating from '{{current_project}}'). For example, if you needed to run `npm install` in a project outside of '{{current_project}}', you would need to prepend with a `cd` i.e. pseudocode for this would be `cd (path to project) && (command, in this case npm install)`.
         - When using the search_files tool, craft your regex patterns carefully to balance specificity and flexibility. Based on the user's task you may use it to find code patterns, TODO comments, function definitions, or any text-based information across the project. The results include context, so analyze the surrounding code to better understand the matches. Leverage the search_files tool in combination with other tools for more comprehensive analysis. For example, use it to find specific code patterns, then use read_file to examine the full context of interesting matches.
         - The write_to_file and replace_in_file tools are ONLY to be used for creating and updating research plans, search strategies, or summarizing findings. They are NOT to be used for modifying system files or any operational code.
         - When making research plans, always consider the context and objectives clearly outlined by the user.
@@ -625,15 +662,11 @@ class BaseAgent(ABC):
         RULES OR  DOCUMENTS PROVIDED BY USER
 
         The following rules are provided by the user, and you must follow them strictly.
-
-        <user_rule_or_document_files>
-        {% for key, value in extra_docs.items() %}
-        <user_rule_or_document_file>
+        
+        {% for key, value in extra_docs.items() %}        
         ##File: {{ key }}
-        {{ value }}
-        </user_rule_or_document_file>
-        {% endfor %}  
-        </user_rule_or_document_files>              
+        {{ value }}        
+        {% endfor %}          
         
         Make sure you always start your task by using the read_file tool to get the relevant RULE files listed in index.md based on the user's specific requirements.        
         {% endif %}
@@ -719,7 +752,7 @@ class BaseAgent(ABC):
             "env_info": env_info,
             "shell_type": shell_type,
             "shell_encoding": shells.get_terminal_encoding(),
-            "conversation_safe_zone_tokens": self.args.conversation_prune_safe_zone_tokens,
+            "conversation_safe_zone_tokens": self._get_parsed_safe_zone_tokens(),
             "os_distribution": shells.get_os_distribution(),
             "current_user": shells.get_current_username(),
             "current_project": os.path.abspath(self.args.source_dir),
@@ -754,6 +787,17 @@ class BaseAgent(ABC):
         conversations = [
             {"role": "system", "content": system_prompt},
         ] 
+        
+        # 恢复对话历史
+        if self.conversation_history:
+            logger.info(f"Restoring conversation history with {len(self.conversation_history)} messages")
+            for message in self.conversation_history:
+                # 确保消息格式正确（包含 role 和 content 字段）
+                if isinstance(message, dict) and 'role' in message and 'content' in message:
+                    conversations.append({
+                        "role": message['role'],
+                        "content": message['content']
+                    })
                                 
         conversations.append({
             "role": "user", "content": request.user_input
@@ -770,10 +814,13 @@ class BaseAgent(ABC):
         should_yield_completion_event = False   
         completion_event = None    
 
-        while True:
+        # 更明确的循环条件，添加最大轮次检查
+        max_iterations = getattr(self.args, 'agentic_max_rounds', 20)
+        while iteration_count <= max_iterations:
             iteration_count += 1            
-            logger.info(f"Starting LLM interaction cycle #{iteration_count}")
-            global_cancel.check_and_raise(token=self.args.event_file)
+            tool_executed = False
+            global_cancel.check_and_raise(token=self.cancel_token or self.args.cancel_token)            
+                
             last_message = conversations[-1]
             if last_message["role"] == "assistant":
                 logger.info(f"Last message is assistant, skipping LLM interaction cycle")
@@ -785,12 +832,18 @@ class BaseAgent(ABC):
                         ), completion_xml="")  
                     else:
                         yield completion_event 
-                break
-            logger.info(
-                f"Starting LLM interaction cycle. History size: {len(conversations)}")
+                break            
 
-            assistant_buffer = ""
-            logger.info("Initializing stream chat with LLM")
+            assistant_buffer = ""            
+
+            # Check if we need to handle max rounds
+            if hasattr(self.args, 'agentic_max_rounds') and iteration_count > self.args.agentic_max_rounds:
+                logger.info(f"Agentic max rounds reached: {self.args.agentic_max_rounds}")
+                yield CompletionEvent(completion=AttemptCompletionTool(
+                    result="Agentic max rounds reached, please try again later",
+                    command=""
+                ), completion_xml="")
+                break
 
             ## 实际请求大模型
             llm_response_gen = stream_chat_with_continue(
@@ -800,37 +853,36 @@ class BaseAgent(ABC):
                 args=self.args
             )
             
-            logger.info("Starting to parse LLM response stream")
             parsed_events = self.stream_and_parse_llm_response(
                 llm_response_gen)
 
             event_count = 0
             mark_event_should_finish = False
             for event in parsed_events:
+                global_cancel.check_and_raise(token=self.cancel_token or self.args.cancel_token)
                 event_count += 1
-                logger.info(f"Processing event #{event_count}: {type(event).__name__}")
-                global_cancel.check_and_raise(token=self.args.event_file)
 
                 if mark_event_should_finish:
                     if isinstance(event, TokenUsageEvent):
-                        logger.info("Yielding token usage event")
                         yield event
                     continue
 
                 if isinstance(event, (LLMOutputEvent, LLMThinkingEvent)):
-                    assistant_buffer += event.text
-                    logger.debug(f"Accumulated {len(assistant_buffer)} chars in assistant buffer")
-                    yield event  # Yield text/thinking immediately for display                    
+                    assistant_buffer += event.text                    
+                    yield event  # Yield text/thinking immediately for display
 
                 elif isinstance(event, ToolCallEvent):
+                    
+                    ## Check for background tasks notifications (basic implementation)
+                    ## This is a simplified version compared to agentic_edit.py
+                    ## Subclasses can override this for more sophisticated handling
+                    
                     tool_executed = True
                     tool_obj = event.tool
                     tool_name = type(tool_obj).__name__
                     logger.info(f"Tool call detected: {tool_name}")
                     tool_xml = event.tool_xml  # Already reconstructed by parser
 
-                    # Append assistant's thoughts and the tool call to history
-                    logger.info(f"Adding assistant message with tool call to conversation history")
                     conversations.append({
                         "role": "assistant",
                         "content": assistant_buffer + tool_xml
@@ -838,29 +890,22 @@ class BaseAgent(ABC):
                     assistant_buffer = ""  # Reset buffer after tool call
 
                     yield event  # Yield the ToolCallEvent for display
-                    logger.info("Yielded ToolCallEvent")
 
                     # Handle AttemptCompletion separately as it ends the loop
-                    if isinstance(tool_obj, AttemptCompletionTool):
-                        logger.info(
-                            "AttemptCompletionTool received. Finalizing session.")
-                        logger.info(f"Completion result: {tool_obj.result[:50]}...")
-                        completion_event = CompletionEvent(completion=tool_obj, completion_xml=tool_xml)
-                        logger.info(
-                            "Agentic analyze loop finished due to AttemptCompletion.")
-                        save_formatted_log(self.args.source_dir, json.dumps(conversations, ensure_ascii=False), "agentic_conversation")    
+                    if isinstance(tool_obj, AttemptCompletionTool):                        
+                        completion_event = CompletionEvent(
+                            completion=tool_obj, completion_xml=tool_xml)                        
+                        save_formatted_log(self.args.source_dir, json.dumps(
+                            conversations, ensure_ascii=False), "agentic_conversation")
                         mark_event_should_finish = True
                         should_yield_completion_event = True
                         continue
 
-                    if isinstance(tool_obj, PlanModeRespondTool):
-                        logger.info(
-                            "PlanModeRespondTool received. Finalizing session.")
-                        logger.info(f"Plan mode response: {tool_obj.response[:50]}...")
+                    if isinstance(tool_obj, PlanModeRespondTool):                                                
                         yield PlanModeRespondEvent(completion=tool_obj, completion_xml=tool_xml)
-                        logger.info(
-                            "AgenticEdit analyze loop finished due to PlanModeRespond.")
-                        save_formatted_log(self.args.source_dir, json.dumps(conversations, ensure_ascii=False), "agentic_conversation")    
+                        save_formatted_log(self.args.source_dir, json.dumps(
+                            conversations, ensure_ascii=False), "agentic_conversation")
+                        mark_event_should_finish = True
                         continue
 
                     # Resolve the tool
@@ -872,7 +917,7 @@ class BaseAgent(ABC):
                             success=False, message="Error: Tool resolver not implemented.", content=None)
                         result_event = ToolResultEvent(tool_name=type(
                             tool_obj).__name__, result=tool_result)
-                        error_xml = f"<tool_result tool_name='{type(tool_obj).__name__}' success='false'><message>Error: Tool resolver not implemented.</message><content></content></tool_result>"
+                        tool_executed_xml = f"<tool_result tool_name='{type(tool_obj).__name__}' success='false'><message>Error: Tool resolver not implemented.</message><content></content></tool_result>"
                     else:
                         try:
                             logger.info(f"Creating resolver for tool: {tool_name}")
@@ -886,15 +931,13 @@ class BaseAgent(ABC):
                             result_event = ToolResultEvent(tool_name=type(
                                 tool_obj).__name__, result=tool_result)
 
-                            # Prepare XML for conversation history
-                            logger.info("Preparing XML for conversation history")
                             escaped_message = xml.sax.saxutils.escape(
                                 tool_result.message)
                             content_str = str(
                                 tool_result.content) if tool_result.content is not None else ""
                             escaped_content = xml.sax.saxutils.escape(
                                 content_str)
-                            error_xml = (
+                            tool_executed_xml = (
                                 f"<tool_result tool_name='{type(tool_obj).__name__}' success='{str(tool_result.success).lower()}'>"
                                 f"<message>{escaped_message}</message>"
                                 f"<content>{escaped_content}</content>"
@@ -910,25 +953,23 @@ class BaseAgent(ABC):
                                 tool_obj).__name__, result=tool_result)
                             escaped_error = xml.sax.saxutils.escape(
                                 error_message)
-                            error_xml = f"<tool_result tool_name='{type(tool_obj).__name__}' success='false'><message>{escaped_error}</message><content></content></tool_result>"
+                            tool_executed_xml = f"<tool_result tool_name='{type(tool_obj).__name__}' success='false'><message>{escaped_error}</message><content></content></tool_result>"
 
-                    yield result_event  # Yield the ToolResultEvent for display    
-                    logger.info("Yielded ToolResultEvent")
+                    yield result_event  # Yield the ToolResultEvent for display
 
-                    # Append the tool result (as user message) to history
-                    logger.info("Adding tool result to conversation history")
+                    # 添加工具结果到对话历史
                     conversations.append({
                         "role": "user",  # Simulating the user providing the tool result
-                        "content": error_xml
+                        "content": tool_executed_xml
                     })
-                    logger.info(
-                        f"Added tool result to conversations for tool {type(tool_obj).__name__}")
-                    logger.info(f"Breaking LLM cycle after executing tool: {tool_name}")
-                    
+
                     # 一次交互只能有一次工具，剩下的其实就没有用了，但是如果不让流式处理完，我们就无法获取服务端
                     # 返回的token消耗和计费，所以通过此标记来完成进入空转，直到流式走完，获取到最后的token消耗和计费
-                    mark_event_should_finish = True
-                    # break  # After tool execution and result, break to start a new LLM cycle
+                    mark_event_should_finish = True                                    
+
+                elif isinstance(event, RetryEvent):
+                    logger.info(f"Retry event occurred: {event.message}")
+                    yield event                    
 
                 elif isinstance(event, ErrorEvent):
                     logger.error(f"Error event occurred: {event.message}")
@@ -936,37 +977,38 @@ class BaseAgent(ABC):
                     # Optionally stop the process on parsing errors
                     # logger.error("Stopping analyze loop due to parsing error.")
                     # return
-                elif isinstance(event, TokenUsageEvent):
-                    logger.info("Yielding token usage event")
-                    yield event                
+                elif isinstance(event, TokenUsageEvent):                    
+                    yield event
             
             if not tool_executed:
                 # No tool executed in this LLM response cycle
-                logger.info("LLM response finished without executing a tool.")                
+                logger.info("LLM response finished without executing a tool.")
                 # Append any remaining assistant buffer to history if it wasn't followed by a tool
                 if assistant_buffer:
-                    logger.info(f"Appending assistant buffer to history: {len(assistant_buffer)} chars")
+
                     last_message = conversations[-1]
                     if last_message["role"] != "assistant":
                         logger.info("Adding new assistant message")
                         conversations.append(
                             {"role": "assistant", "content": assistant_buffer})
+
                     elif last_message["role"] == "assistant":
                         logger.info("Appending to existing assistant message")
                         last_message["content"] += assistant_buffer
-                
+
                 # 添加系统提示，要求LLM必须使用工具或明确结束，而不是直接退出
-                logger.info("Adding system reminder to use tools or attempt completion")
+                logger.info(
+                    "Adding system reminder to use tools or attempt completion")
+
                 conversations.append({
                     "role": "user",
                     "content": "NOTE: You must use an appropriate tool (such as read_file, write_to_file, execute_command, etc.) or explicitly complete the task (using attempt_completion). Do not provide text responses without taking concrete actions. Please select a suitable tool to continue based on the user's task."
                 })
-                # 继续循环，让 LLM 再思考，而不是 break
-                logger.info("Continuing the LLM interaction loop without breaking")
+                                
                 continue
             
-        logger.info(f"Agentic analyze loop finished after {iteration_count} iterations.")
-        save_formatted_log(self.args.source_dir, json.dumps(conversations, ensure_ascii=False), "agentic_conversation")        
+        logger.info(f"AgenticEdit analyze loop finished after {iteration_count} iterations.")
+        save_formatted_log(self.args.source_dir, json.dumps(conversations, ensure_ascii=False), "agentic_conversation")
     
     def stream_and_parse_llm_response(
         self, generator: Generator[Tuple[str, Any], None, None]
@@ -986,10 +1028,17 @@ class BaseAgent(ABC):
         in_tool_block = False
         in_thinking_block = False
         current_tool_tag = None
-        tool_start_pattern = re.compile(
-            r"<([a-zA-Z0-9_]+)>")  # Matches tool tags
+        
+        # 预编译正则表达式以提高性能
+        tool_start_pattern = re.compile(r"<([a-zA-Z0-9_]+)>")
+        _tool_end_pattern = re.compile(r"</([a-zA-Z0-9_]+)>")
         thinking_start_tag = "<thinking>"
         thinking_end_tag = "</thinking>"
+        _param_pattern = re.compile(r"<([a-zA-Z0-9_]+)>(.*?)</\1>", re.DOTALL)
+        
+        # 性能监控
+        start_time = time.time()
+        event_count = 0
 
         def parse_tool_xml(tool_xml: str, tool_tag: str) -> Optional[BaseTool]:
             """Minimal parser for tool XML string."""
@@ -1049,7 +1098,7 @@ class BaseAgent(ABC):
         
         last_metadata = None      
         for content_chunk, metadata in generator:
-            global_cancel.check_and_raise(token=self.args.event_file)                      
+            global_cancel.check_and_raise(token=self.cancel_token or self.args.cancel_token)                      
             if not content_chunk:
                 last_metadata = metadata                
                 continue
@@ -1095,9 +1144,9 @@ class BaseAgent(ABC):
                             else:
                                 yield ToolCallEvent(tool=tool_obj, tool_xml=reconstructed_xml)
                         else:
-                            yield ErrorEvent(message=f"Failed to parse tool: <{current_tool_tag}>")
+                            # yield ErrorEvent(message=f"Failed to parse tool: <{current_tool_tag}>")
                             # Optionally yield the raw XML as plain text?
-                            # yield LLMOutputEvent(text=tool_xml)
+                            yield LLMOutputEvent(text=f"Failed to parse tool: <{current_tool_tag}> {tool_xml}")
 
                         buffer = buffer[tool_block_end_index:]
                         in_tool_block = False
@@ -1170,19 +1219,25 @@ class BaseAgent(ABC):
         # After generator exhausted, yield any remaining content
         if in_thinking_block:
             # Unterminated thinking block
-            yield ErrorEvent(message="Stream ended with unterminated <thinking> block.")
+            yield RetryEvent(message="Stream ended with unterminated <thinking> block.")
             if buffer:
                 # Yield remaining as thinking
                 yield LLMThinkingEvent(text=buffer)
         elif in_tool_block:
             # Unterminated tool block
-            yield ErrorEvent(message=f"Stream ended with unterminated <{current_tool_tag}> block.")
+            yield RetryEvent(message=f"Stream ended with unterminated <{current_tool_tag}> block.")
             if buffer:
                 yield LLMOutputEvent(text=buffer)  # Yield remaining as text
         elif buffer:
             # Yield remaining plain text
             yield LLMOutputEvent(text=buffer)
 
+        # 性能日志
+        duration = time.time() - start_time
+        logger.info(
+            f"Event stream processing completed: {event_count} events in {duration:.3f}s "
+            f"({event_count/max(duration, 0.001):.1f} events/sec)")
+            
         # 这个要放在最后，防止其他关联的多个事件的信息中断
         yield TokenUsageEvent(usage=last_metadata)     
     
@@ -1243,20 +1298,48 @@ class BaseAgent(ABC):
                     event_manager.write_result(
                         content=content.to_dict(), metadata=metadata.to_dict())
                 elif isinstance(agent_event, TokenUsageEvent):
-                    # 获取模型信息以计算价格
-                    model_name = ",".join(llms_utils.get_llm_names(self.llm))
-                    model_info = llms_utils.get_model_info(
-                        model_name, self.args.product_mode) or {}
-                    input_price = model_info.get("input_price", 0.0) if model_info else 0.0
-                    output_price = model_info.get("output_price", 0.0) if model_info else 0.0
+                    # 缓存模型价格信息
+                    if not hasattr(self, '_cached_model_info'):
+                        model_name = ",".join(llms_utils.get_llm_names(self.llm))
+                        self._cached_model_info = llms_utils.get_model_info(
+                            model_name, self.args.product_mode) or {}
+                        self._cached_model_name = model_name
+
+                    # 获取价格
+                    input_price = self._cached_model_info.get("input_price", 0.0)
+                    output_price = self._cached_model_info.get("output_price", 0.0)
 
                     # 计算成本
                     last_meta = agent_event.usage
-                    input_cost = (last_meta.input_tokens_count * input_price) / 1000000  # 转换为百万
-                    output_cost = (last_meta.generated_tokens_count * output_price) / 1000000
+                    input_tokens = max(last_meta.input_tokens_count, 0)
+                    output_tokens = max(last_meta.generated_tokens_count, 0)
+                    
+                    input_cost = (input_tokens * input_price) / 1000000  # 转换为百万
+                    output_cost = (output_tokens * output_price) / 1000000
+
+                    # 预测总成本
+                    if not hasattr(self, '_total_input_tokens'):
+                        self._total_input_tokens = 0
+                        self._total_output_tokens = 0
+                        self._total_input_cost = 0.0
+                        self._total_output_cost = 0.0
+                    
+                    self._total_input_tokens += input_tokens
+                    self._total_output_tokens += output_tokens
+                    self._total_input_cost += input_cost
+                    self._total_output_cost += output_cost
 
-                    # 记录Token使用详情
-                    logger.info(f"Token Usage Details: Model={model_name}, Input Tokens={last_meta.input_tokens_count}, Output Tokens={last_meta.generated_tokens_count}, Input Cost=${input_cost:.6f}, Output Cost=${output_cost:.6f}")
+                    # 记录详细Token使用情况
+                    logger.info(
+                        f"Token Usage Details:\n"
+                        f"- Model: {self._cached_model_name}\n"
+                        f"- Input: {input_tokens} tokens (${input_cost:.6f})\n"
+                        f"- Output: {output_tokens} tokens (${output_cost:.6f})\n"
+                        f"- Running Totals:\n"
+                        f"  - Input: {self._total_input_tokens} tokens (${self._total_input_cost:.6f})\n"
+                        f"  - Output: {self._total_output_tokens} tokens (${self._total_output_cost:.6f})\n"
+                        f"- Estimated Final Cost: ${(self._total_input_cost + self._total_output_cost) * 1.2:.6f} (with 20% buffer)"
+                    )
 
                     # 写入Token统计事件
                     get_event_manager(self.args.event_file).write_result(
@@ -1439,6 +1522,8 @@ class BaseAgent(ABC):
                     yield ("result",event.completion.result)
                     if event.completion.command:
                         yield ("result", agentic_lang.get_message_with_format("suggested_command", command=event.completion.command))
+                elif isinstance(event, RetryEvent):
+                    yield ("thinking", agentic_lang.get_message_with_format("retry_message", message=event.message))
                 elif isinstance(event, ErrorEvent):
                     yield ("result", agentic_lang.get_message("error_title"))
                     yield ("result", agentic_lang.get_message_with_format("error_content", message=event.message))                    
@@ -1453,16 +1538,15 @@ class BaseAgent(ABC):
         finally:
             # 在结束时打印累计的token使用情况
             duration = time.time() - start_time            
-            yield ("result","\n" + self.printer.get_message_from_key_with_format("code_generation_complete",
-                duration=duration,
-                input_tokens=total_input_tokens,
-                output_tokens=total_output_tokens,
-                input_cost=total_input_cost,
-                output_cost=total_output_cost,
-                speed=0.0,
-                model_names=model_name,
-                sampling_count=1))
-            yield ("result", "\n" + agentic_lang.get_message("agent_execution_complete"))
+            # yield ("result","\n" + self.printer.get_message_from_key_with_format("code_generation_complete",
+            #     duration=duration,
+            #     input_tokens=total_input_tokens,
+            #     output_tokens=total_output_tokens,
+            #     input_cost=total_input_cost,
+            #     output_cost=total_output_cost,
+            #     speed=0.0,
+            #     model_names=model_name,
+            #     sampling_count=1))            
     
     def run_in_terminal(self, request: AgentRequest):
         """
@@ -1746,4 +1830,19 @@ class BaseAgent(ABC):
                     )
         else:
             self.printer.print_in_terminal("no_changes_made")
-            
+    
+    @byzerllm.prompt(render="jinja2")
+    def git_require_msg(self, source_dir: str, error: str) -> str:
+        '''
+        auto_merge only works for git repositories.
+         
+        Try to use git init in the source directory. 
+        
+        ```shell
+        cd {{ source_dir }}
+        git init .
+        ```
+
+        Then try to run auto-coder again.
+        Error: {{ error }}
+        '''