auto-coder 0.1.363__py3-none-any.whl → 0.1.364__py3-none-any.whl

autocoder/common/v2/agent/agentic_edit.py

@@ -40,9 +40,15 @@ from autocoder.linters.shadow_linter import ShadowLinter
 from autocoder.compilers.shadow_compiler import ShadowCompiler
 from autocoder.common.action_yml_file_manager import ActionYmlFileManager
 from autocoder.common.auto_coder_lang import get_message
+from autocoder.common.save_formatted_log import save_formatted_log
 # Import the new display function
 from autocoder.common.v2.agent.agentic_tool_display import get_tool_display_message
 from autocoder.common.v2.agent.agentic_edit_types import FileChangeEntry
+
+from autocoder.common.file_checkpoint.models import FileChange as CheckpointFileChange
+from autocoder.common.file_checkpoint.manager import FileChangeManager as CheckpointFileChangeManager
+from autocoder.linters.normal_linter import NormalLinter
+from autocoder.compilers.normal_compiler import NormalCompiler
 from autocoder.common.v2.agent.agentic_edit_tools import (  # Import specific resolvers
     BaseToolResolver,
     ExecuteCommandToolResolver, ReadFileToolResolver, WriteToFileToolResolver,
@@ -51,7 +57,7 @@ from autocoder.common.v2.agent.agentic_edit_tools import (  # Import specific re
     AttemptCompletionToolResolver, PlanModeRespondToolResolver, UseMcpToolResolver,
     ListPackageInfoToolResolver
 )
-from autocoder.common.rulefiles.autocoderrules_utils import get_rules
+from autocoder.common.rulefiles.autocoderrules_utils import get_rules,auto_select_rules,get_required_and_index_rules
 from autocoder.common.v2.agent.agentic_edit_types import (AgenticEditRequest, ToolResult,
                                                           MemoryConfig, CommandConfig, BaseTool,
                                                           ExecuteCommandTool, ReadFileTool,
@@ -101,7 +107,7 @@ class AgenticEdit:
         args: AutoCoderArgs,
         memory_config: MemoryConfig,
         command_config: Optional[CommandConfig] = None,
-        conversation_name: str = "current"
+        conversation_name:Optional[str] = "current"        
     ):
         self.llm = llm
         self.args = args
@@ -116,11 +122,22 @@ class AgenticEdit:
         self.project_type_analyzer = ProjectTypeAnalyzer(
             args=args, llm=self.llm)        
 
-        self.shadow_manager = ShadowManager(
-            args.source_dir, args.event_file, args.ignore_clean_shadows)
-        self.shadow_linter = ShadowLinter(self.shadow_manager, verbose=False)
-        self.shadow_compiler = ShadowCompiler(
-            self.shadow_manager, verbose=False)
+        # self.shadow_manager = ShadowManager(
+        #     args.source_dir, args.event_file, args.ignore_clean_shadows)
+        self.shadow_manager = None
+        # self.shadow_linter = ShadowLinter(self.shadow_manager, verbose=False)
+        self.shadow_compiler = None
+        # self.shadow_compiler = ShadowCompiler(self.shadow_manager, verbose=False)
+        self.shadow_linter = None
+
+        self.checkpoint_manager = CheckpointFileChangeManager(
+            project_dir=args.source_dir,
+            backup_dir=os.path.join(args.source_dir,".auto-coder","checkpoint"),
+            store_dir=os.path.join(args.source_dir,".auto-coder","checkpoint_store"),
+            max_history=50)
+        self.linter = NormalLinter(args.source_dir,verbose=False)
+        self.compiler = NormalCompiler(args.source_dir,verbose=False)        
+            
 
         self.mcp_server_info = ""
         try:
@@ -663,12 +680,14 @@ class AgenticEdit:
         The following rules are provided by the user, and you must follow them strictly.
 
         {% for key, value in extra_docs.items() %}
-        <user_rule>
+        <user_rule_file>
         ##File: {{ key }}
         {{ value }}
-        </user_rule>
-        {% endfor %}        
+        </user_rule_file>
+        {% 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 %}
+        
 
         ====
 
@@ -694,14 +713,15 @@ class AgenticEdit:
         {% if file_paths_str %}
         ====
         The following are files that the user is currently focusing on. 
-        Make sure you always start your analysis by using the read_file tool to get the content of the files.
+        Make sure you always start your task by using the read_file tool to get the content of the files.
         <files>
         {{file_paths_str}}
         </files>
         {% endif %}
-        """
-        import os
-        extra_docs = get_rules()
+        """        
+        ## auto_select_rules(context=request.user_input, llm=self.llm,args=self.args)        rules =       
+        # extra_docs = get_rules()  
+        extra_docs = get_required_and_index_rules()   
         
         env_info = detect_env()
         shell_type = "bash"
@@ -790,9 +810,7 @@ class AgenticEdit:
         
         logger.info(
             f"Initial conversation history size: {len(conversations)}")
-        
-        logger.info(f"Conversation history: {json.dumps(conversations, indent=2,ensure_ascii=False)}")
-
+                
         iteration_count = 0
         tool_executed = False
         while True:
@@ -828,7 +846,7 @@ class AgenticEdit:
             event_count = 0
             for event in parsed_events:
                 event_count += 1
-                logger.info(f"Processing event #{event_count}: {type(event).__name__}")
+                # logger.info(f"Processing event #{event_count}: {type(event).__name__}")
                 global_cancel.check_and_raise(token=self.args.event_file)
                 if isinstance(event, (LLMOutputEvent, LLMThinkingEvent)):
                     assistant_buffer += event.text
@@ -861,6 +879,7 @@ class AgenticEdit:
                         yield CompletionEvent(completion=tool_obj, completion_xml=tool_xml)
                         logger.info(
                             "AgenticEdit analyze loop finished due to AttemptCompletion.")
+                        save_formatted_log(self.args.source_dir, json.dumps(conversations, ensure_ascii=False), "agentic_conversation")        
                         return
 
                     if isinstance(tool_obj, PlanModeRespondTool):
@@ -870,6 +889,7 @@ class AgenticEdit:
                         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")        
                         return
 
                     # Resolve the tool
@@ -972,6 +992,7 @@ class AgenticEdit:
                 continue
             
         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]
@@ -1187,174 +1208,28 @@ class AgenticEdit:
         elif buffer:
             # Yield remaining plain text
             yield LLMOutputEvent(text=buffer)
-
-    def run_with_events(self, request: AgenticEditRequest):
-        """
-        Runs the agentic edit process, converting internal events to the
-        standard event system format and writing them using the event manager.
-        """
-        event_manager = get_event_manager(self.args.event_file)
-        self.apply_pre_changes()
-
-        try:
-            event_stream = self.analyze(request)
-            for agent_event in event_stream:
-                content = None
-                metadata = EventMetadata(
-                    action_file=self.args.file,
-                    is_streaming=False,
-                    stream_out_type="/agent/edit")
-
-                if isinstance(agent_event, LLMThinkingEvent):
-                    content = EventContentCreator.create_stream_thinking(
-                        content=agent_event.text)
-                    metadata.is_streaming = True
-                    metadata.path = "/agent/edit/thinking"
-                    event_manager.write_stream(
-                        content=content.to_dict(), metadata=metadata.to_dict())
-                elif isinstance(agent_event, LLMOutputEvent):
-                    content = EventContentCreator.create_stream_content(
-                        content=agent_event.text)
-                    metadata.is_streaming = True
-                    metadata.path = "/agent/edit/output"
-                    event_manager.write_stream(content=content.to_dict(),
-                                               metadata=metadata.to_dict())
-                elif isinstance(agent_event, ToolCallEvent):
-                    tool_name = type(agent_event.tool).__name__
-                    metadata.path = "/agent/edit/tool/call"
-                    content = EventContentCreator.create_result(
-                        content={
-                            "tool_name": tool_name,
-                            **agent_event.tool.model_dump()
-                        },
-                        metadata={}
-                    )
-                    event_manager.write_result(
-                        content=content.to_dict(), metadata=metadata.to_dict())
-                elif isinstance(agent_event, ToolResultEvent):
-                    metadata.path = "/agent/edit/tool/result"
-                    content = EventContentCreator.create_result(
-                        content={
-                            "tool_name": agent_event.tool_name,
-                            **agent_event.result.model_dump()
-                        },
-                        metadata={}
-                    )
-                    event_manager.write_result(
-                        content=content.to_dict(), metadata=metadata.to_dict())
-                elif isinstance(agent_event, PlanModeRespondEvent):
-                    metadata.path = "/agent/edit/plan_mode_respond"
-                    content = EventContentCreator.create_markdown_result(
-                        content=agent_event.completion.response,
-                        metadata={}
-                    )
-                    event_manager.write_result(
-                        content=content.to_dict(), metadata=metadata.to_dict())
-
-                elif isinstance(agent_event, TokenUsageEvent):
-                    last_meta: SingleOutputMeta = agent_event.usage
-                    # Get model info for pricing
-                    from autocoder.utils import llms as llm_utils
-                    model_name = ",".join(llm_utils.get_llm_names(self.llm))
-                    model_info = llm_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
-
-                    # Calculate costs
-                    input_cost = (last_meta.input_tokens_count *
-                                  input_price) / 1000000  # Convert to millions
-                    # Convert to millions
-                    output_cost = (
-                        last_meta.generated_tokens_count * output_price) / 1000000
-
-                    # 添加日志记录
-                    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}")
-
-                    get_event_manager(self.args.event_file).write_result(
-                        EventContentCreator.create_result(content=EventContentCreator.ResultTokenStatContent(
-                            model_name=model_name,
-                            elapsed_time=0.0,
-                            first_token_time=last_meta.first_token_time,
-                            input_tokens=last_meta.input_tokens_count,
-                            output_tokens=last_meta.generated_tokens_count,
-                            input_cost=input_cost,
-                            output_cost=output_cost
-                        ).to_dict()), metadata=metadata.to_dict())
-
-                elif isinstance(agent_event, CompletionEvent):
-                    # 在这里完成实际合并
-                    try:
-                        self.apply_changes()
-                    except Exception as e:
-                        logger.exception(
-                            f"Error merging shadow changes to project: {e}")
-
-                    metadata.path = "/agent/edit/completion"
-                    content = EventContentCreator.create_completion(
-                        success_code="AGENT_COMPLETE",
-                        success_message="Agent attempted task completion.",
-                        result={
-                            "response": agent_event.completion.result
-                        }
-                    )
-                    event_manager.write_completion(
-                        content=content.to_dict(), metadata=metadata.to_dict())
-                elif isinstance(agent_event, ErrorEvent):
-                    metadata.path = "/agent/edit/error"
-                    content = EventContentCreator.create_error(
-                        error_code="AGENT_ERROR",
-                        error_message=agent_event.message,
-                        details={"agent_event_type": "ErrorEvent"}
-                    )
-                    event_manager.write_error(
-                        content=content.to_dict(), metadata=metadata.to_dict())
-                else:
-                    metadata.path = "/agent/edit/error"
-                    logger.warning(
-                        f"Unhandled agent event type: {type(agent_event)}")
-                    content = EventContentCreator.create_error(
-                        error_code="AGENT_ERROR",
-                        error_message=f"Unhandled agent event type: {type(agent_event)}",
-                        details={"agent_event_type": type(
-                            agent_event).__name__}
-                    )
-                    event_manager.write_error(
-                        content=content.to_dict(), metadata=metadata.to_dict())
-
-        except Exception as e:
-            logger.exception(
-                "An unexpected error occurred during agent execution:")
-            metadata = EventMetadata(
-                action_file=self.args.file,
-                is_streaming=False,
-                stream_out_type="/agent/edit/error")
-            error_content = EventContentCreator.create_error(
-                error_code="AGENT_FATAL_ERROR",
-                error_message=f"An unexpected error occurred: {str(e)}",
-                details={"exception_type": type(e).__name__}
-            )
-            event_manager.write_error(
-                content=error_content.to_dict(), metadata=metadata.to_dict())
-            # Re-raise the exception if needed, or handle appropriately
-            raise e
+    
 
     def apply_pre_changes(self):
         # get the file name
         file_name = os.path.basename(self.args.file)
         if not self.args.skip_commit:
             try:
+                commit_result = git_utils.commit_changes(
+                    self.args.source_dir, f"auto_coder_pre_{file_name}")
                 get_event_manager(self.args.event_file).write_result(
                     EventContentCreator.create_result(
-                        content=self.printer.get_message_from_key("/agent/edit/apply_pre_changes")), metadata=EventMetadata(
+                        content={
+                            "have_commit":commit_result.success,
+                            "commit_hash":commit_result.commit_hash,
+                            "diff_file_num":len(commit_result.changed_files),
+                            "event_file":self.args.event_file
+                        }), metadata=EventMetadata(
                         action_file=self.args.file,
                         is_streaming=False,
                         path="/agent/edit/apply_pre_changes",
                         stream_out_type="/agent/edit").to_dict())
-                git_utils.commit_changes(
-                    self.args.source_dir, f"auto_coder_pre_{file_name}")
+                
             except Exception as e:
                 self.printer.print_in_terminal("git_init_required",
                                                source_dir=self.args.source_dir, error=str(e))
@@ -1364,16 +1239,22 @@ class AgenticEdit:
         """
         Apply all tracked file changes to the original project directory.
         """
-        for (file_path, change) in self.get_all_file_changes().items():
-            # Ensure the directory exists before writing the file
-            dir_path = os.path.dirname(file_path)
-            if dir_path: # Ensure dir_path is not empty (for files in root)
-                 os.makedirs(dir_path, exist_ok=True)
-
-            with open(file_path, 'w', encoding='utf-8') as f:
-                f.write(change.content)
-
-        if len(self.get_all_file_changes()) > 0:
+        diff_file_num = 0
+        if self.shadow_manager:
+            for (file_path, change) in self.get_all_file_changes().items():
+                # Ensure the directory exists before writing the file
+                dir_path = os.path.dirname(file_path)
+                if dir_path: # Ensure dir_path is not empty (for files in root)
+                    os.makedirs(dir_path, exist_ok=True)
+
+                with open(file_path, 'w', encoding='utf-8') as f:
+                    f.write(change.content)
+            diff_file_num = len(self.get_all_file_changes())  
+        else:          
+            changes = self.checkpoint_manager.get_changes_by_group(self.args.event_file)
+            diff_file_num = len(changes)
+            
+        if diff_file_num > 0:
             if not self.args.skip_commit:
                 try:
                     file_name = os.path.basename(self.args.file)
@@ -1381,13 +1262,20 @@ class AgenticEdit:
                         self.args.source_dir,
                         f"{self.args.query}\nauto_coder_{file_name}",
                     )
-
+                    
                     get_event_manager(self.args.event_file).write_result(
                         EventContentCreator.create_result(
-                            content=self.printer.get_message_from_key("/agent/edit/apply_changes")), metadata=EventMetadata(
+                            content={
+                                "have_commit":commit_result.success,
+                                "commit_hash":commit_result.commit_hash,
+                                "diff_file_num":diff_file_num,
+                                "event_file":self.args.event_file                                
+                            }), metadata=EventMetadata(
                             action_file=self.args.file,
                             is_streaming=False,
+                            path="/agent/edit/apply_changes",
                             stream_out_type="/agent/edit").to_dict())
+                    
                     action_yml_file_manager = ActionYmlFileManager(
                         self.args.source_dir)
                     action_file_name = os.path.basename(self.args.file)
@@ -1433,6 +1321,15 @@ class AgenticEdit:
         console.print(Panel(
             f"[bold]{get_message('/agent/edit/user_query')}:[/bold]\n{request.user_input}", title=get_message("/agent/edit/objective"), border_style="blue"))
 
+        # 用于累计TokenUsageEvent数据
+        accumulated_token_usage = {
+            "model_name": "",
+            "input_tokens": 0,
+            "output_tokens": 0,
+            "input_cost": 0.0,
+            "output_cost": 0.0
+        }
+
         try:
             self.apply_pre_changes()
             event_stream = self.analyze(request)
@@ -1459,17 +1356,12 @@ class AgenticEdit:
                     # 添加日志记录
                     logger.info(f"Token Usage: 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}")
 
-                    self.printer.print_in_terminal(
-                            "code_generation_complete",
-                            duration=0.0,
-                            input_tokens=last_meta.input_tokens_count,
-                            output_tokens=last_meta.generated_tokens_count,
-                            input_cost=input_cost,
-                            output_cost=output_cost,
-                            speed=0.0,
-                            model_names=model_name,
-                            sampling_count=1
-                        )
+                    # 累计token使用情况
+                    accumulated_token_usage["model_name"] = model_name
+                    accumulated_token_usage["input_tokens"] += last_meta.input_tokens_count
+                    accumulated_token_usage["output_tokens"] += last_meta.generated_tokens_count
+                    accumulated_token_usage["input_cost"] += input_cost
+                    accumulated_token_usage["output_cost"] += output_cost
                     
                 if isinstance(event, LLMThinkingEvent):
                     # Render thinking within a less prominent style, maybe grey?
@@ -1592,7 +1484,35 @@ class AgenticEdit:
 
                 time.sleep(0.1)  # Small delay for better visual flow
 
+            # 在处理完所有事件后打印累计的token使用情况
+            if accumulated_token_usage["input_tokens"] > 0:
+                self.printer.print_in_terminal(
+                    "code_generation_complete",
+                    duration=0.0,
+                    input_tokens=accumulated_token_usage["input_tokens"],
+                    output_tokens=accumulated_token_usage["output_tokens"],
+                    input_cost=accumulated_token_usage["input_cost"],
+                    output_cost=accumulated_token_usage["output_cost"],
+                    speed=0.0,
+                    model_names=accumulated_token_usage["model_name"],
+                    sampling_count=1
+                )
+                
         except Exception as e:
+            # 在处理异常时也打印累计的token使用情况
+            if accumulated_token_usage["input_tokens"] > 0:
+                self.printer.print_in_terminal(
+                    "code_generation_complete",
+                    duration=0.0,
+                    input_tokens=accumulated_token_usage["input_tokens"],
+                    output_tokens=accumulated_token_usage["output_tokens"],
+                    input_cost=accumulated_token_usage["input_cost"],
+                    output_cost=accumulated_token_usage["output_cost"],
+                    speed=0.0,
+                    model_names=accumulated_token_usage["model_name"],
+                    sampling_count=1
+                )
+                
             logger.exception(
                 "An unexpected error occurred during agent execution:")
             console.print(Panel(
@@ -1600,3 +1520,204 @@ class AgenticEdit:
             raise e
         finally:
             console.rule("[bold cyan]Agentic Edit Finished[/]")
+
+    def run_with_events(self, request: AgenticEditRequest):
+        """
+        Runs the agentic edit process, converting internal events to the
+        standard event system format and writing them using the event manager.
+        """
+        event_manager = get_event_manager(self.args.event_file)
+        self.apply_pre_changes()
+
+        # 用于累计TokenUsageEvent数据
+        accumulated_token_usage = {
+            "model_name": "",
+            "elapsed_time": 0.0,
+            "first_token_time": 0.0,
+            "input_tokens": 0,
+            "output_tokens": 0,
+            "input_cost": 0.0,
+            "output_cost": 0.0
+        }
+
+        try:
+            event_stream = self.analyze(request)
+            for agent_event in event_stream:
+                content = None
+                metadata = EventMetadata(
+                    action_file=self.args.file,
+                    is_streaming=False,
+                    stream_out_type="/agent/edit")
+
+                if isinstance(agent_event, LLMThinkingEvent):
+                    content = EventContentCreator.create_stream_thinking(
+                        content=agent_event.text)
+                    metadata.is_streaming = True
+                    metadata.path = "/agent/edit/thinking"
+                    event_manager.write_stream(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+                elif isinstance(agent_event, LLMOutputEvent):
+                    content = EventContentCreator.create_stream_content(
+                        content=agent_event.text)
+                    metadata.is_streaming = True
+                    metadata.path = "/agent/edit/output"
+                    event_manager.write_stream(content=content.to_dict(),
+                                            metadata=metadata.to_dict())
+                elif isinstance(agent_event, ToolCallEvent):
+                    tool_name = type(agent_event.tool).__name__
+                    metadata.path = "/agent/edit/tool/call"
+                    content = EventContentCreator.create_result(
+                        content={
+                            "tool_name": tool_name,
+                            **agent_event.tool.model_dump()
+                        },
+                        metadata={}
+                    )
+                    event_manager.write_result(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+                elif isinstance(agent_event, ToolResultEvent):
+                    metadata.path = "/agent/edit/tool/result"
+                    content = EventContentCreator.create_result(
+                        content={
+                            "tool_name": agent_event.tool_name,
+                            **agent_event.result.model_dump()
+                        },
+                        metadata={}
+                    )
+                    event_manager.write_result(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+                elif isinstance(agent_event, PlanModeRespondEvent):
+                    metadata.path = "/agent/edit/plan_mode_respond"
+                    content = EventContentCreator.create_markdown_result(
+                        content=agent_event.completion.response,
+                        metadata={}
+                    )
+                    event_manager.write_result(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+
+                elif isinstance(agent_event, TokenUsageEvent):
+                    last_meta: SingleOutputMeta = agent_event.usage
+                    # Get model info for pricing
+                    from autocoder.utils import llms as llm_utils
+                    model_name = ",".join(llm_utils.get_llm_names(self.llm))
+                    model_info = llm_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
+
+                    # Calculate costs
+                    input_cost = (last_meta.input_tokens_count *
+                                input_price) / 1000000  # Convert to millions
+                    # Convert to millions
+                    output_cost = (
+                        last_meta.generated_tokens_count * output_price) / 1000000
+
+                    # 添加日志记录
+                    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}")
+
+                    # 累计TokenUsageEvent数据而不是立即发送
+                    accumulated_token_usage["model_name"] = model_name
+                    if accumulated_token_usage["first_token_time"] == 0.0:
+                        accumulated_token_usage["first_token_time"] = last_meta.first_token_time
+                    accumulated_token_usage["input_tokens"] += last_meta.input_tokens_count
+                    accumulated_token_usage["output_tokens"] += last_meta.generated_tokens_count
+                    accumulated_token_usage["input_cost"] += input_cost
+                    accumulated_token_usage["output_cost"] += output_cost
+
+                elif isinstance(agent_event, CompletionEvent):
+                    # 在这里完成实际合并
+                    try:
+                        self.apply_changes()
+                    except Exception as e:
+                        logger.exception(
+                            f"Error merging shadow changes to project: {e}")
+                    
+                    # 发送累计的TokenUsageEvent数据
+                    get_event_manager(self.args.event_file).write_result(
+                        EventContentCreator.create_result(content=EventContentCreator.ResultTokenStatContent(
+                            model_name=accumulated_token_usage["model_name"],
+                            elapsed_time=0.0,
+                            first_token_time=accumulated_token_usage["first_token_time"],
+                            input_tokens=accumulated_token_usage["input_tokens"],
+                            output_tokens=accumulated_token_usage["output_tokens"],
+                            input_cost=accumulated_token_usage["input_cost"],
+                            output_cost=accumulated_token_usage["output_cost"]
+                        ).to_dict()), metadata=metadata.to_dict())
+
+                    metadata.path = "/agent/edit/completion"
+                    content = EventContentCreator.create_completion(
+                        success_code="AGENT_COMPLETE",
+                        success_message="Agent attempted task completion.",
+                        result={
+                            "response": agent_event.completion.result
+                        }
+                    )
+                    event_manager.write_completion(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+                elif isinstance(agent_event, ErrorEvent):
+                    # 发送累计的TokenUsageEvent数据（在错误情况下也需要发送）
+                    if accumulated_token_usage["input_tokens"] > 0:
+                        get_event_manager(self.args.event_file).write_result(
+                            EventContentCreator.create_result(content=EventContentCreator.ResultTokenStatContent(
+                                model_name=accumulated_token_usage["model_name"],
+                                elapsed_time=0.0,
+                                first_token_time=accumulated_token_usage["first_token_time"],
+                                input_tokens=accumulated_token_usage["input_tokens"],
+                                output_tokens=accumulated_token_usage["output_tokens"],
+                                input_cost=accumulated_token_usage["input_cost"],
+                                output_cost=accumulated_token_usage["output_cost"]
+                            ).to_dict()), metadata=metadata.to_dict())
+                    
+                    metadata.path = "/agent/edit/error"
+                    content = EventContentCreator.create_error(
+                        error_code="AGENT_ERROR",
+                        error_message=agent_event.message,
+                        details={"agent_event_type": "ErrorEvent"}
+                    )
+                    event_manager.write_error(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+                else:
+                    metadata.path = "/agent/edit/error"
+                    logger.warning(
+                        f"Unhandled agent event type: {type(agent_event)}")
+                    content = EventContentCreator.create_error(
+                        error_code="AGENT_ERROR",
+                        error_message=f"Unhandled agent event type: {type(agent_event)}",
+                        details={"agent_event_type": type(
+                            agent_event).__name__}
+                    )
+                    event_manager.write_error(
+                        content=content.to_dict(), metadata=metadata.to_dict())
+
+        except Exception as e:
+            logger.exception(
+                "An unexpected error occurred during agent execution:")
+            metadata = EventMetadata(
+                action_file=self.args.file,
+                is_streaming=False,
+                stream_out_type="/agent/edit/error")
+                
+            # 发送累计的TokenUsageEvent数据（在错误情况下也需要发送）
+            if accumulated_token_usage["input_tokens"] > 0:
+                get_event_manager(self.args.event_file).write_result(
+                    EventContentCreator.create_result(content=EventContentCreator.ResultTokenStatContent(
+                        model_name=accumulated_token_usage["model_name"],
+                        elapsed_time=0.0,
+                        first_token_time=accumulated_token_usage["first_token_time"],
+                        input_tokens=accumulated_token_usage["input_tokens"],
+                        output_tokens=accumulated_token_usage["output_tokens"],
+                        input_cost=accumulated_token_usage["input_cost"],
+                        output_cost=accumulated_token_usage["output_cost"]
+                    ).to_dict()), metadata=metadata.to_dict())
+                
+            error_content = EventContentCreator.create_error(
+                error_code="AGENT_FATAL_ERROR",
+                error_message=f"An unexpected error occurred: {str(e)}",
+                details={"exception_type": type(e).__name__}
+            )
+            event_manager.write_error(
+                content=error_content.to_dict(), metadata=metadata.to_dict())
+            # Re-raise the exception if needed, or handle appropriately
+            raise e