auto-coder 0.1.364__tar.gz → 0.1.366__tar.gz

{auto_coder-0.1.364 → auto_coder-0.1.366}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.364
+Version: 0.1.366
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.10

{auto_coder-0.1.364 → auto_coder-0.1.366}/src/auto_coder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.364
+Version: 0.1.366
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.10

{auto_coder-0.1.364 → auto_coder-0.1.366}/src/auto_coder.egg-info/SOURCES.txt

@@ -141,6 +141,7 @@ src/autocoder/common/directory_cache/cache.py
 src/autocoder/common/directory_cache/test_cache.py
 src/autocoder/common/file_checkpoint/__init__.py
 src/autocoder/common/file_checkpoint/backup.py
+src/autocoder/common/file_checkpoint/conversation_checkpoint.py
 src/autocoder/common/file_checkpoint/examples.py
 src/autocoder/common/file_checkpoint/manager.py
 src/autocoder/common/file_checkpoint/models.py

{auto_coder-0.1.364 → auto_coder-0.1.366}/src/autocoder/agent/base_agentic/base_agent.py

@@ -794,10 +794,18 @@ class BaseAgent(ABC):
                 llm_response_gen)
 
             event_count = 0
+            mark_event_should_finish = False
             for event in parsed_events:
                 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")
@@ -903,7 +911,11 @@ class BaseAgent(ABC):
                     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}")
-                    break  # After tool execution and result, break to start a new LLM cycle
+                    
+                    # 一次交互只能有一次工具，剩下的其实就没有用了，但是如果不让流式处理完，我们就无法获取服务端
+                    # 返回的token消耗和计费，所以通过此标记来完成进入空转，直到流式走完，获取到最后的token消耗和计费
+                    mark_event_should_finish = True
+                    # break  # After tool execution and result, break to start a new LLM cycle
 
                 elif isinstance(event, ErrorEvent):
                     logger.error(f"Error event occurred: {event.message}")
@@ -1022,13 +1034,15 @@ class BaseAgent(ABC):
                     f"Failed to parse tool XML for <{tool_tag}>: {e}\nXML:\n{tool_xml}")
                 return None
         
-        meta_holder = byzerllm.MetaHolder() 
+        last_metadata = None      
         for content_chunk, metadata in generator:
-            global_cancel.check_and_raise(token=self.args.event_file)                                    
-            meta_holder.meta = metadata            
+            global_cancel.check_and_raise(token=self.args.event_file)                      
             if not content_chunk:
+                last_metadata = metadata                
                 continue
-            buffer += content_chunk
+            
+            last_metadata = metadata
+            buffer += content_chunk  
 
             while True:
                 # Check for transitions: thinking -> text, tool -> text, text -> thinking, text -> tool
@@ -1138,9 +1152,7 @@ class BaseAgent(ABC):
 
                 # If no event was processed in this iteration, break inner loop
                 if not found_event:
-                    break
-        
-        yield TokenUsageEvent(usage=meta_holder.meta)        
+                    break               
 
         # After generator exhausted, yield any remaining content
         if in_thinking_block:
@@ -1157,6 +1169,9 @@ class BaseAgent(ABC):
         elif buffer:
             # Yield remaining plain text
             yield LLMOutputEvent(text=buffer)
+
+        # 这个要放在最后，防止其他关联的多个事件的信息中断
+        yield TokenUsageEvent(usage=last_metadata)     
     
     def run_with_events(self, request: AgentRequest):
         """

{auto_coder-0.1.364 → auto_coder-0.1.366}/src/autocoder/auto_coder.py

@@ -376,8 +376,8 @@ def main(input_args: Optional[List[str]] = None):
                 llm.setup_sub_client("inference_model", inference_model)                 
 
             if args.index_filter_model:
-                model_info = models_module.get_model_by_name(args.index_filter_model)
-                model_name = args.index_filter_model
+                model_name = args.index_filter_model.strip()
+                model_info = models_module.get_model_by_name(model_name)                
                 index_filter_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 index_filter_model.deploy(
                     model_path="",
@@ -393,6 +393,41 @@ def main(input_args: Optional[List[str]] = None):
                 )
                 llm.setup_sub_client("index_filter_model", index_filter_model)            
 
+            if args.context_prune_model:
+                model_name = args.context_prune_model.strip()
+                model_info = models_module.get_model_by_name(model_name)                
+                context_prune_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
+                context_prune_model.deploy(
+                    model_path="",
+                    pretrained_model_type=model_info["model_type"],
+                    udf_name=model_name,
+                    infer_params={
+                        "saas.base_url": model_info["base_url"],
+                        "saas.api_key": model_info["api_key"],
+                        "saas.model": model_info["model_name"],
+                        "saas.is_reasoning": model_info["is_reasoning"],
+                        "saas.max_output_tokens": model_info.get("max_output_tokens", 8096)
+                    }
+                )
+                llm.setup_sub_client("context_prune_model", context_prune_model)
+
+            if args.conversation_prune_model:
+                model_name = args.conversation_prune_model.strip()
+                model_info = models_module.get_model_by_name(model_name)                
+                conversation_prune_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
+                conversation_prune_model.deploy(
+                    model_path="",
+                    pretrained_model_type=model_info["model_type"],
+                    udf_name=model_name,
+                    infer_params={
+                        "saas.base_url": model_info["base_url"],
+                        "saas.api_key": model_info["api_key"],
+                        "saas.model": model_info["model_name"],
+                        "saas.is_reasoning": model_info["is_reasoning"],
+                        "saas.max_output_tokens": model_info.get("max_output_tokens", 8096)
+                    }
+                )
+                llm.setup_sub_client("conversation_prune_model", conversation_prune_model)
 
         if args.product_mode == "pro":
             if args.code_model:
@@ -437,6 +472,15 @@ def main(input_args: Optional[List[str]] = None):
                 index_filter_model.setup_default_model_name(args.index_filter_model)
                 llm.setup_sub_client("index_filter_model", index_filter_model)
             
+            if args.context_prune_model:
+                context_prune_model = byzerllm.ByzerLLM()
+                context_prune_model.setup_default_model_name(args.context_prune_model)
+                llm.setup_sub_client("context_prune_model", context_prune_model)
+
+            if args.conversation_prune_model:
+                conversation_prune_model = byzerllm.ByzerLLM()
+                conversation_prune_model.setup_default_model_name(args.conversation_prune_model)
+                llm.setup_sub_client("conversation_prune_model", conversation_prune_model)
 
         if get_run_context().mode != RunMode.WEB and args.human_as_model:
 

{auto_coder-0.1.364 → auto_coder-0.1.366}/src/autocoder/common/__init__.py

@@ -254,6 +254,8 @@ class AutoCoderArgs(pydantic.BaseModel):
     emb_model: Optional[str] = ""
     code_model: Optional[str] = ""
     generate_rerank_model: Optional[str] = ""
+    context_prune_model: Optional[str] = ""
+    conversation_prune_model: Optional[str] = ""
     inference_model: Optional[str] = ""
     system_prompt: Optional[str] = ""
     planner_model: Optional[str] = ""
@@ -399,6 +401,7 @@ class AutoCoderArgs(pydantic.BaseModel):
 
     context_prune_strategy: Optional[str] = "extract"
     context_prune: Optional[bool] = True
+    context_prune_safe_zone_tokens: Optional[int] = 32*1024
     context_prune_sliding_window_size: Optional[int] = 1000
     context_prune_sliding_window_overlap: Optional[int] = 100
 

auto_coder-0.1.366/src/autocoder/common/file_checkpoint/conversation_checkpoint.py

@@ -0,0 +1,182 @@
+import os
+import json
+import time
+import uuid
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel
+from loguru import logger
+
+
+class ConversationCheckpoint(BaseModel):
+    """对话检查点，用于保存特定时刻的对话状态"""
+    
+    checkpoint_id: str  # 检查点ID，与变更组ID对应
+    timestamp: float  # 创建时间戳
+    conversations: List[Dict[str, Any]]  # 对话历史
+    metadata: Optional[Dict[str, Any]] = None  # 元数据，可包含额外信息
+
+
+class ConversationCheckpointStore:
+    """对话检查点存储管理器"""
+    
+    def __init__(self, store_dir: Optional[str] = None, max_history: int = 50):
+        """
+        初始化对话检查点存储
+        
+        Args:
+            store_dir: 存储目录，默认为用户主目录下的.autocoder/conversation_checkpoints
+            max_history: 最大保存的历史版本数量
+        """
+        if store_dir is None:
+            home_dir = os.path.expanduser("~")
+            store_dir = os.path.join(home_dir, ".autocoder", "conversation_checkpoints")
+        
+        self.store_dir = os.path.abspath(store_dir)
+        self.max_history = max_history
+        
+        # 确保存储目录存在
+        os.makedirs(self.store_dir, exist_ok=True)
+        logger.info(f"对话检查点存储目录: {self.store_dir}")
+    
+    def save_checkpoint(self, checkpoint: ConversationCheckpoint) -> str:
+        """
+        保存对话检查点
+        
+        Args:
+            checkpoint: 对话检查点对象
+            
+        Returns:
+            str: 检查点ID
+        """
+        # 确保检查点有ID
+        if not checkpoint.checkpoint_id:
+            checkpoint.checkpoint_id = str(uuid.uuid4())
+        
+        # 确保时间戳存在
+        if not checkpoint.timestamp:
+            checkpoint.timestamp = time.time()
+        
+        # 构建文件路径
+        file_path = os.path.join(self.store_dir, f"{checkpoint.checkpoint_id}.json")
+        
+        # 保存为JSON文件
+        try:
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(checkpoint.json(ensure_ascii=False, indent=2))
+            
+            logger.info(f"已保存对话检查点: {checkpoint.checkpoint_id}")
+            
+            # 检查并清理过期的检查点
+            self._cleanup_old_checkpoints()
+            
+            return checkpoint.checkpoint_id
+        except Exception as e:
+            logger.error(f"保存对话检查点失败: {str(e)}")
+            return ""
+    
+    def get_checkpoint(self, checkpoint_id: str) -> Optional[ConversationCheckpoint]:
+        """
+        获取指定ID的对话检查点
+        
+        Args:
+            checkpoint_id: 检查点ID
+            
+        Returns:
+            Optional[ConversationCheckpoint]: 对话检查点对象，如果不存在则返回None
+        """
+        file_path = os.path.join(self.store_dir, f"{checkpoint_id}.json")
+        
+        if not os.path.exists(file_path):
+            logger.warning(f"对话检查点不存在: {checkpoint_id}")
+            return None
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            return ConversationCheckpoint(**data)
+        except Exception as e:
+            logger.error(f"读取对话检查点失败: {str(e)}")
+            return None
+    
+    def get_latest_checkpoint(self) -> Optional[ConversationCheckpoint]:
+        """
+        获取最新的对话检查点
+        
+        Returns:
+            Optional[ConversationCheckpoint]: 最新的对话检查点对象，如果不存在则返回None
+        """
+        checkpoints = self._get_all_checkpoints()
+        
+        if not checkpoints:
+            return None
+        
+        # 按时间戳降序排序
+        checkpoints.sort(key=lambda x: x.timestamp, reverse=True)
+        
+        return checkpoints[0] if checkpoints else None
+    
+    def delete_checkpoint(self, checkpoint_id: str) -> bool:
+        """
+        删除指定的对话检查点
+        
+        Args:
+            checkpoint_id: 检查点ID
+            
+        Returns:
+            bool: 是否成功删除
+        """
+        file_path = os.path.join(self.store_dir, f"{checkpoint_id}.json")
+        
+        if not os.path.exists(file_path):
+            logger.warning(f"要删除的对话检查点不存在: {checkpoint_id}")
+            return False
+        
+        try:
+            os.remove(file_path)
+            logger.info(f"已删除对话检查点: {checkpoint_id}")
+            return True
+        except Exception as e:
+            logger.error(f"删除对话检查点失败: {str(e)}")
+            return False
+    
+    def _get_all_checkpoints(self) -> List[ConversationCheckpoint]:
+        """
+        获取所有对话检查点
+        
+        Returns:
+            List[ConversationCheckpoint]: 对话检查点列表
+        """
+        checkpoints = []
+        
+        try:
+            for filename in os.listdir(self.store_dir):
+                if filename.endswith('.json'):
+                    file_path = os.path.join(self.store_dir, filename)
+                    
+                    try:
+                        with open(file_path, 'r', encoding='utf-8') as f:
+                            data = json.load(f)
+                        
+                        checkpoint = ConversationCheckpoint(**data)
+                        checkpoints.append(checkpoint)
+                    except Exception as e:
+                        logger.error(f"读取对话检查点文件失败 {filename}: {str(e)}")
+        except Exception as e:
+            logger.error(f"获取所有对话检查点失败: {str(e)}")
+        
+        return checkpoints
+    
+    def _cleanup_old_checkpoints(self):
+        """清理过期的检查点，保持历史记录数量在限制范围内"""
+        checkpoints = self._get_all_checkpoints()
+        
+        if len(checkpoints) <= self.max_history:
+            return
+        
+        # 按时间戳降序排序
+        checkpoints.sort(key=lambda x: x.timestamp, reverse=True)
+        
+        # 删除超出限制的旧检查点
+        for checkpoint in checkpoints[self.max_history:]:
+            self.delete_checkpoint(checkpoint.checkpoint_id)

{auto_coder-0.1.364 → auto_coder-0.1.366}/src/autocoder/common/file_checkpoint/manager.py

@@ -8,6 +8,7 @@ import os
 import uuid
 import logging
 import difflib
+import time
 from typing import Dict, List, Optional, Tuple, Any
 from datetime import datetime
 
@@ -16,6 +17,7 @@ from autocoder.common.file_checkpoint.models import (
 )
 from autocoder.common.file_checkpoint.backup import FileBackupManager
 from autocoder.common.file_checkpoint.store import FileChangeStore
+from autocoder.common.file_checkpoint.conversation_checkpoint import ConversationCheckpointStore,ConversationCheckpoint
 
 logger = logging.getLogger(__name__)
 
@@ -24,7 +26,8 @@ class FileChangeManager:
     """文件变更管理器，提供高层次的API接口"""
     
     def __init__(self, project_dir: str, backup_dir: Optional[str] = None, 
-                 store_dir: Optional[str] = None, max_history: int = 50):
+                 store_dir: Optional[str] = None, max_history: int = 50,
+                 conversation_store_dir: Optional[str] = None):
         """
         初始化文件变更管理器
         
@@ -33,10 +36,61 @@ class FileChangeManager:
             backup_dir: 备份文件存储目录，默认为用户主目录下的.autocoder/backups
             store_dir: 变更记录存储目录，默认为用户主目录下的.autocoder/changes
             max_history: 最大保存的历史版本数量
+            conversation_store_dir: 对话检查点存储目录
         """
         self.project_dir = os.path.abspath(project_dir)
         self.backup_manager = FileBackupManager(backup_dir)
         self.change_store = FileChangeStore(store_dir, max_history)
+        
+        # 初始化对话检查点存储
+        if conversation_store_dir is None and store_dir is not None:
+            # 默认在变更记录存储目录的同级目录创建 conversation_checkpoints 目录
+            parent_dir = os.path.dirname(store_dir)
+            conversation_store_dir = os.path.join(parent_dir, "conversation_checkpoints")
+        
+        try:            
+            self.conversation_store = ConversationCheckpointStore(conversation_store_dir, max_history)
+            logger.info(f"对话检查点存储初始化成功: {conversation_store_dir}")
+        except ImportError as e:
+            logger.warning(f"对话检查点存储初始化失败: {str(e)}")
+            self.conversation_store = None
+    
+    def apply_changes_with_conversation(self, changes: Dict[str, FileChange], 
+                                   conversations: List[Dict[str, Any]],
+                                   change_group_id: Optional[str] = None,
+                                   metadata: Optional[Dict[str, Any]] = None) -> ApplyResult:
+        """
+        应用文件变更并保存对话状态
+        
+        Args:
+            changes: 文件变更字典，格式为 {file_path: FileChange}
+            conversations: 当前对话历史
+            change_group_id: 变更组ID，用于将相关变更归为一组
+            metadata: 元数据，可包含额外信息
+            
+        Returns:
+            ApplyResult: 应用结果对象
+        """
+        # 应用文件变更
+        result = self.apply_changes(changes, change_group_id)
+        
+        if result.success and self.conversation_store is not None:
+            try:                
+                
+                # 创建并保存对话检查点
+                checkpoint_id = change_group_id or result.change_ids[0] if result.change_ids else str(uuid.uuid4())
+                checkpoint = ConversationCheckpoint(
+                    checkpoint_id=checkpoint_id,
+                    timestamp=time.time(),
+                    conversations=conversations,
+                    metadata=metadata
+                )
+                self.conversation_store.save_checkpoint(checkpoint)
+                logger.info(f"已保存对话检查点: {checkpoint_id}")
+            except Exception as e:
+                logger.error(f"保存对话检查点失败: {str(e)}")
+        
+        return result
     
     def apply_changes(self, changes: Dict[str, FileChange], change_group_id: Optional[str] = None) -> ApplyResult:
         """
@@ -152,6 +206,27 @@ class FileChangeManager:
         
         return diff_results
     
+    def undo_last_change_with_conversation(self) -> Tuple[UndoResult, Optional[ConversationCheckpoint]]:
+        """
+        撤销最近的一次变更并恢复对话状态
+        
+        Returns:
+            Tuple[UndoResult, Optional[ConversationCheckpoint]]: 撤销结果和恢复的对话检查点
+        """
+        # 获取最近的变更记录
+        latest_changes = self.change_store.get_latest_changes(limit=1)
+        if not latest_changes:
+            return UndoResult(success=False, errors={"general": "没有找到最近的变更记录"}), None
+        
+        latest_change = latest_changes[0]
+        
+        # 如果最近的变更属于一个组，撤销整个组
+        if latest_change.group_id:
+            return self.undo_change_group_with_conversation(latest_change.group_id)
+        else:
+            # 否则只撤销这一个变更
+            return self.undo_change_with_conversation(latest_change.change_id)
+    
     def undo_last_change(self) -> UndoResult:
         """
         撤销最近的一次变更
@@ -173,6 +248,39 @@ class FileChangeManager:
             # 否则只撤销这一个变更
             return self.undo_change(latest_change.change_id)
     
+    def undo_change_with_conversation(self, change_id: str) -> Tuple[UndoResult, Optional[ConversationCheckpoint]]:
+        """
+        撤销指定的变更并恢复对话状态
+        
+        Args:
+            change_id: 变更记录ID
+            
+        Returns:
+            Tuple[UndoResult, Optional[ConversationCheckpoint]]: 撤销结果和恢复的对话检查点
+        """
+        # 获取变更记录
+        change_record = self.change_store.get_change(change_id)
+        if change_record is None:
+            return UndoResult(success=False, errors={"general": f"变更记录 {change_id} 不存在"}), None
+        
+        # 获取关联的对话检查点
+        checkpoint = None
+        checkpoint_id = change_record.group_id or change_id
+        if self.conversation_store is not None:
+            try:
+                checkpoint = self.conversation_store.get_checkpoint(checkpoint_id)
+                if checkpoint:
+                    logger.info(f"找到关联的对话检查点: {checkpoint_id}")
+                else:
+                    logger.info(f"未找到关联的对话检查点: {checkpoint_id}")
+            except Exception as e:
+                logger.error(f"获取对话检查点失败: {str(e)}")
+        
+        # 撤销文件变更
+        undo_result = self.undo_change(change_id)
+        
+        return undo_result, checkpoint
+    
     def undo_change(self, change_id: str) -> UndoResult:
         """
         撤销指定的变更
@@ -234,6 +342,38 @@ class FileChangeManager:
         
         return result
             
+    def undo_change_group_with_conversation(self, group_id: str) -> Tuple[UndoResult, Optional[ConversationCheckpoint]]:
+        """
+        撤销指定组的所有变更并恢复对话状态
+        
+        Args:
+            group_id: 变更组ID
+            
+        Returns:
+            Tuple[UndoResult, Optional[ConversationCheckpoint]]: 撤销结果和恢复的对话检查点
+        """
+        # 获取组内的所有变更记录
+        changes = self.change_store.get_changes_by_group(group_id)
+        if not changes:
+            return UndoResult(success=False, errors={"general": f"变更组 {group_id} 不存在或为空"}), None
+        
+        # 获取关联的对话检查点
+        checkpoint = None
+        if self.conversation_store is not None:
+            try:
+                checkpoint = self.conversation_store.get_checkpoint(group_id)
+                if checkpoint:
+                    logger.info(f"找到关联的对话检查点: {group_id}")
+                else:
+                    logger.info(f"未找到关联的对话检查点: {group_id}")
+            except Exception as e:
+                logger.error(f"获取对话检查点失败: {str(e)}")
+        
+        # 撤销文件变更
+        undo_result = self.undo_change_group(group_id)
+        
+        return undo_result, checkpoint
+    
     def undo_change_group(self, group_id: str) -> UndoResult:
         """
         撤销指定组的所有变更
@@ -265,6 +405,39 @@ class FileChangeManager:
         
         return result
     
+    def undo_to_version_with_conversation(self, version_id: str) -> Tuple[UndoResult, Optional[ConversationCheckpoint]]:
+        """
+        撤销到指定的历史版本并恢复对话状态
+        
+        Args:
+            version_id: 目标版本ID（变更记录ID）
+            
+        Returns:
+            Tuple[UndoResult, Optional[ConversationCheckpoint]]: 撤销结果和恢复的对话检查点
+        """
+        # 获取目标版本的变更记录
+        target_change = self.change_store.get_change(version_id)
+        if target_change is None:
+            return UndoResult(success=False, errors={"general": f"变更记录 {version_id} 不存在"}), None
+        
+        # 获取关联的对话检查点
+        checkpoint = None
+        checkpoint_id = target_change.group_id or version_id
+        if self.conversation_store is not None:
+            try:
+                checkpoint = self.conversation_store.get_checkpoint(checkpoint_id)
+                if checkpoint:
+                    logger.info(f"找到关联的对话检查点: {checkpoint_id}")
+                else:
+                    logger.info(f"未找到关联的对话检查点: {checkpoint_id}")
+            except Exception as e:
+                logger.error(f"获取对话检查点失败: {str(e)}")
+        
+        # 撤销文件变更
+        undo_result = self.undo_to_version(version_id)
+        
+        return undo_result, checkpoint
+    
     def undo_to_version(self, version_id: str) -> UndoResult:
         """
         撤销到指定的历史版本
@@ -359,6 +532,41 @@ class FileChangeManager:
         """
         return self.change_store.get_change_groups(limit)
     
+    def get_available_checkpoints(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """
+        获取可用的检查点列表，包含对话状态信息
+        
+        Args:
+            limit: 返回的检查点数量限制
+            
+        Returns:
+            List[Dict[str, Any]]: 检查点信息列表
+        """
+        # 获取变更组列表
+        change_groups = self.get_change_groups(limit)
+        
+        # 构建检查点信息
+        checkpoints = []
+        for group_id, timestamp, count in change_groups:
+            has_conversation = False
+            
+            # 检查是否有对话检查点
+            if self.conversation_store is not None:
+                try:
+                    checkpoint = self.conversation_store.get_checkpoint(group_id)
+                    has_conversation = checkpoint is not None
+                except Exception as e:
+                    logger.error(f"获取对话检查点失败: {str(e)}")
+            
+            checkpoints.append({
+                "id": group_id,
+                "timestamp": timestamp,
+                "changes_count": count,
+                "has_conversation": has_conversation
+            })
+        
+        return checkpoints
+    
     def get_diff_text(self, old_content: str, new_content: str) -> str:
         """
         获取两个文本内容的差异文本

{auto_coder-0.1.364 → auto_coder-0.1.366}/src/autocoder/common/utils_code_auto_generate.py

@@ -72,7 +72,7 @@ def stream_chat_with_continue(
     """
     
     count = 0
-    temp_conversations = conversations
+    temp_conversations = [] + conversations
     current_metadata = None
     metadatas = {}
     while True:
@@ -89,7 +89,8 @@ def stream_chat_with_continue(
             content = res[0]
             current_content += content 
             if current_metadata is None:
-                current_metadata = res[1]            
+                current_metadata = res[1]      
+                metadatas[count] = res[1]      
             else:
                 metadatas[count] = res[1]                
                 current_metadata.finish_reason = res[1].finish_reason