auto-coder-web 0.1.91__py3-none-any.whl → 0.1.93__py3-none-any.whl

auto_coder_web/routers/auto_router.py

@@ -16,6 +16,10 @@ from byzerllm.utils.langutil import asyncfy_with_semaphore
 from autocoder.common.global_cancel import global_cancel, CancelRequestedException 
 from loguru import logger
 import byzerllm
+# 导入聊天会话和聊天列表管理器
+from auto_coder_web.common_router.chat_session_manager import read_session_name_sync
+from auto_coder_web.common_router.chat_list_manager import get_chat_list_sync
+
 router = APIRouter()
 
 # 创建线程池
@@ -25,6 +29,7 @@ class AutoCommandRequest(BaseModel):
     command: str
     include_conversation_history: bool = True
     buildin_conversation_history: bool = False
+    panel_id: Optional[str] = None
 
 class EventPollRequest(BaseModel):
     event_file_id:str    
@@ -102,40 +107,39 @@ async def auto_command(request: AutoCommandRequest, project_path: str = Depends(
 
             if request.include_conversation_history:
                 # 获取当前会话名称
-                current_session_file = os.path.join(project_path, ".auto-coder", "auto-coder.web", "current-session.json")
+                panel_id = request.panel_id or ""
                 current_session_name = ""
-                if os.path.exists(current_session_file):
-                    try:
-                        with open(current_session_file, 'r',encoding="utf-8") as f:
-                            session_data = json.load(f)
-                            current_session_name = session_data.get("session_name", "")
-                    except Exception as e:                        
-                        logger.error(f"Error reading current session: {str(e)}")
-                        logger.exception(e)
+                try:
+                    # 使用chat_session_manager模块获取当前会话名称
+                    # 使用同步版本的函数，避免在线程中使用asyncio.run
+                    current_session_name = read_session_name_sync(project_path, panel_id)
+                except Exception as e:                        
+                    logger.error(f"Error reading current session: {str(e)}")
+                    logger.exception(e)
                 
                 # 获取历史消息
                 messages = []
                 if current_session_name:
-                    chat_list_file = os.path.join(project_path, ".auto-coder", "auto-coder.web", "chat-lists", f"{current_session_name}.json")
-                    logger.info(f"loading chat history from {chat_list_file}")
-                    if os.path.exists(chat_list_file):
-                        try:
-                            with open(chat_list_file, 'r', encoding="utf-8") as f:                                
-                                chat_data = json.load(f)
-                                # 从聊天历史中提取消息
-                                for msg in chat_data.get("messages", []):                                    
-                                    # if msg.get("metadata",{}).get("stream_out_type","") == "/agent/edit":
-                                    #     messages.append(msg)
-                                    #     continue
-                                    
-                                    # if msg.get("type","") not in ["USER_RESPONSE","RESULT","COMPLETION"]:
-                                    #     continue     
-                                    if msg.get("contentType","") in ["token_stat"]:
-                                        continue                                                                
-                                    messages.append(msg)
-                        except Exception as e:                                                       
-                            logger.error(f"Error reading chat history: {str(e)}")
-                            logger.exception(e) 
+                    try:
+                        # 使用chat_list_manager模块获取聊天列表内容
+                        logger.info(f"Loading chat history for session: {current_session_name}")
+                        # 使用同步版本的函数，避免在线程中使用asyncio.run
+                        chat_data = get_chat_list_sync(project_path, current_session_name)
+                        
+                        # 从聊天历史中提取消息
+                        for msg in chat_data.get("messages", []):                                    
+                            # if msg.get("metadata",{}).get("stream_out_type","") == "/agent/edit":
+                            #     messages.append(msg)
+                            #     continue
+                            
+                            # if msg.get("type","") not in ["USER_RESPONSE","RESULT","COMPLETION"]:
+                            #     continue     
+                            if msg.get("contentType","") in ["token_stat"]:
+                                continue                                                                
+                            messages.append(msg)
+                    except Exception as e:                                                       
+                        logger.error(f"Error reading chat history: {str(e)}")
+                        logger.exception(e) 
                                                 
                 if messages:
                     # 调用coding_prompt生成包含历史消息的提示

auto_coder_web/routers/chat_panels_router.py

@@ -0,0 +1,159 @@
+import os
+import json
+import aiofiles
+from fastapi import APIRouter, HTTPException, Request, Depends
+from pydantic import BaseModel
+from pathlib import Path
+from typing import List, Optional
+
+router = APIRouter()
+
+# 定义数据模型
+class ChatTab(BaseModel):
+    id: str
+    name: str
+
+class ChatPanelsConfig(BaseModel):
+    tabs: List[ChatTab] = [
+        ChatTab(id="main", name="主线面板"),
+        ChatTab(id="secondary", name="支线面板")
+    ]
+    activeTabId: str = "main"
+
+async def get_project_path(request: Request) -> str:
+    """从FastAPI请求上下文中获取项目路径"""
+    return request.app.state.project_path
+
+async def get_config_path(project_path: str) -> Path:
+    """获取聊天面板配置文件路径"""
+    config_path = Path(project_path) / ".auto-coder" / "auto-coder.web" / "chat_panels.json"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    return config_path
+
+async def load_config(config_path: Path) -> ChatPanelsConfig:
+    """加载聊天面板配置"""
+    if not config_path.exists():
+        return ChatPanelsConfig()
+    
+    try:
+        async with aiofiles.open(config_path, mode='r', encoding='utf-8') as f:
+            content = await f.read()
+            config_data = json.loads(content)
+            return ChatPanelsConfig(**config_data)
+    except FileNotFoundError:
+        return ChatPanelsConfig()
+    except json.JSONDecodeError:
+        # 处理配置文件损坏或为空的情况
+        return ChatPanelsConfig()
+
+async def save_config(config: ChatPanelsConfig, config_path: Path):
+    """保存聊天面板配置"""
+    async with aiofiles.open(config_path, mode='w', encoding='utf-8') as f:
+        await f.write(json.dumps(config.dict(), indent=2, ensure_ascii=False))
+
+# 获取所有聊天标签页
+@router.get("/api/chat/panels")
+async def get_chat_panels(request: Request):
+    """获取所有聊天标签页配置"""
+    project_path = await get_project_path(request)
+    config_path = await get_config_path(project_path)
+    config = await load_config(config_path)
+    return config.dict()
+
+# 更新聊天标签页列表
+@router.put("/api/chat/panels/tabs")
+async def update_chat_tabs(
+    tabs: List[ChatTab],
+    request: Request
+):
+    """更新聊天标签页列表"""
+    if not tabs:
+        raise HTTPException(status_code=400, detail="聊天标签页列表不能为空")
+    
+    project_path = await get_project_path(request)
+    config_path = await get_config_path(project_path)
+    config = await load_config(config_path)
+    config.tabs = tabs
+    
+    # 如果当前活跃标签不在新列表中，设置为第一个标签
+    tab_ids = [tab.id for tab in tabs]
+    if config.activeTabId not in tab_ids and tab_ids:
+        config.activeTabId = tab_ids[0]
+        
+    await save_config(config, config_path)
+    return config.dict()
+
+# 更新当前活跃标签
+@router.put("/api/chat/panels/active-tab")
+async def update_active_tab(
+    active_tab: dict,
+    request: Request
+):
+    """更新当前活跃的聊天标签页"""
+    tab_id = active_tab.get("id")
+    if not tab_id:
+        raise HTTPException(status_code=400, detail="必须提供标签页ID")
+    
+    project_path = await get_project_path(request)
+    config_path = await get_config_path(project_path)
+    config = await load_config(config_path)
+    
+    # 确保指定的标签页存在
+    tab_ids = [tab.id for tab in config.tabs]
+    if tab_id not in tab_ids:
+        raise HTTPException(status_code=404, detail=f"标签页ID '{tab_id}' 不存在")
+    
+    config.activeTabId = tab_id
+    await save_config(config, config_path)
+    return {"activeTabId": tab_id}
+
+# 添加新标签页
+@router.post("/api/chat/panels/tabs")
+async def add_chat_tab(
+    tab: ChatTab,
+    request: Request
+):
+    """添加新的聊天标签页"""
+    if not tab.id or not tab.name:
+        raise HTTPException(status_code=400, detail="标签页必须包含ID和名称")
+    
+    project_path = await get_project_path(request)
+    config_path = await get_config_path(project_path)
+    config = await load_config(config_path)
+    
+    # 检查ID是否已存在
+    if any(existing_tab.id == tab.id for existing_tab in config.tabs):
+        raise HTTPException(status_code=400, detail=f"标签页ID '{tab.id}' 已存在")
+    
+    config.tabs.append(tab)
+    await save_config(config, config_path)
+    return tab.dict()
+
+# 删除标签页
+@router.delete("/api/chat/panels/tabs/{tab_id}")
+async def delete_chat_tab(
+    tab_id: str,
+    request: Request
+):
+    """删除指定的聊天标签页"""
+    project_path = await get_project_path(request)
+    config_path = await get_config_path(project_path)
+    config = await load_config(config_path)
+    
+    # 确保至少保留一个标签页
+    if len(config.tabs) <= 1:
+        raise HTTPException(status_code=400, detail="必须至少保留一个聊天标签页")
+    
+    # 查找并删除标签页
+    initial_length = len(config.tabs)
+    config.tabs = [tab for tab in config.tabs if tab.id != tab_id]
+    
+    if len(config.tabs) == initial_length:
+        raise HTTPException(status_code=404, detail=f"标签页ID '{tab_id}' 不存在")
+    
+    # 如果删除的是当前活跃标签，切换到第一个标签
+    if config.activeTabId == tab_id:
+        config.activeTabId = config.tabs[0].id
+    
+    await save_config(config, config_path)
+    return {"success": True, "activeTabId": config.activeTabId} 

auto_coder_web/routers/chat_router.py

@@ -15,6 +15,10 @@ from autocoder.events.event_types import EventType
 from byzerllm.utils.langutil import asyncfy_with_semaphore
 from autocoder.common.global_cancel import global_cancel, CancelRequestedException 
 from loguru import logger
+import byzerllm
+# 导入聊天会话和聊天列表管理器
+from auto_coder_web.common_router.chat_session_manager import read_session_name_sync
+from auto_coder_web.common_router.chat_list_manager import get_chat_list_sync
 
 router = APIRouter()
 
@@ -23,6 +27,7 @@ cancel_thread_pool = ThreadPoolExecutor(max_workers=5)
 
 class ChatCommandRequest(BaseModel):
     command: str
+    panel_id: Optional[str] = None
 
 class EventPollRequest(BaseModel):
     event_file_id: str    
@@ -42,6 +47,10 @@ class TaskHistoryRequest(BaseModel):
 class CancelTaskRequest(BaseModel):
     event_file_id: str
 
+class ChatResetRequest(BaseModel):
+    session_id: str
+    panel_id: Optional[str] = "main"
+
 async def get_project_path(request: Request) -> str:
     """
     从FastAPI请求上下文中获取项目路径
@@ -54,6 +63,25 @@ def ensure_task_dir(project_path: str) -> str:
     os.makedirs(task_dir, exist_ok=True)
     return task_dir
 
+@byzerllm.prompt()
+def chat_prompt(messages: List[Dict[str, Any]], request: ChatCommandRequest):
+    '''
+    下面是我们已经产生的一个消息列表,其中 USER_RESPONSE 表示用户的输入，其他都是你的输出：
+    <messages>
+    {% for message in messages %}
+    <message>
+    <type>{{ message.type }}</type>
+    <content>{{ message.content }}</content>
+    </message>
+    {% endfor %}
+    </messages>
+    
+    下面是用户的最新需求：
+    <request>
+    {{ request.command }}    
+    </request>
+    '''
+
 @router.post("/api/chat-command")
 async def chat_command(request: ChatCommandRequest, project_path: str = Depends(get_project_path)):
     """
@@ -71,8 +99,45 @@ async def chat_command(request: ChatCommandRequest, project_path: str = Depends(
             wrapper.configure_wrapper(f"event_file:{event_file}")    
             global_cancel.register_token(event_file)
 
+            # 获取当前会话名称
+            panel_id = request.panel_id or ""
+            try:
+                # 使用同步版本的会话管理函数，传递panel_id参数
+                current_session_name = read_session_name_sync(project_path, panel_id)
+            except Exception as e:
+                logger.error(f"Error reading current session: {str(e)}")
+                current_session_name = ""
+            
+            # 获取历史消息
+            messages = []
+            if current_session_name:
+                try:
+                    # 使用同步版本的聊天列表管理函数
+                    logger.info(f"Loading chat history for session: {current_session_name}")
+                    chat_data = get_chat_list_sync(project_path, current_session_name)
+                    
+                    # 从聊天历史中提取消息
+                    for msg in chat_data.get("messages", []):
+                        # 只保留用户和中间结果信息
+                        if msg.get("type","") not in ["USER_RESPONSE","RESULT"]:
+                            continue     
+
+                        if msg.get("contentType","") in ["token_stat"]:
+                            continue                            
+                        
+                        messages.append(msg)
+                except Exception as e:
+                    logger.error(f"Error reading chat history: {str(e)}")
+            
+            # 构建提示信息
+            prompt_text = request.command
+            if messages:
+                # 调用chat_prompt生成包含历史消息的提示
+                prompt_text = chat_prompt.prompt(messages, request)
+
             # 调用chat方法
-            result = wrapper.chat_wrapper(request.command)            
+            logger.info(f"Prompt text: {prompt_text}")
+            result = wrapper.chat_wrapper(prompt_text)            
             get_event_manager(event_file).write_completion(
                 EventContentCreator.create_completion(
                     "200", "completed", result).to_dict()
@@ -289,6 +354,60 @@ async def get_task_detail(task_id: str, project_path: str = Depends(get_project_
         raise HTTPException(
             status_code=500, detail=f"Failed to get task detail: {str(e)}")
 
+@router.post("/api/chat/reset")
+async def reset_chat(request: ChatResetRequest, project_path: str = Depends(get_project_path)):
+    """
+    重置聊天会话
+    
+    通过AutoCoderRunnerWrapper调用chat方法，执行/new命令重置会话
+    在单独的线程中运行，并返回一个唯一的UUID
+    
+    Args:
+        request: 包含session_id和panel_id的请求对象
+        project_path: 项目路径
+        
+    Returns:
+        重置操作的结果
+    """
+    # 生成事件文件路径
+    event_file, file_id = gengerate_event_file_path()
+    
+    # 定义在线程中运行的函数
+    def run_reset_in_thread():
+        try:
+            # 加载tokenizer
+            from autocoder.auto_coder_runner import load_tokenizer
+            load_tokenizer()
+            
+            # 创建AutoCoderRunnerWrapper实例
+            wrapper = AutoCoderRunnerWrapper(project_path)
+            wrapper.configure_wrapper(f"event_file:{event_file}")
+            global_cancel.register_token(event_file)
+            
+            # 调用chat方法，执行/new命令
+            result = wrapper.chat_wrapper("/new")
+            
+            # 写入完成事件
+            get_event_manager(event_file).write_completion(
+                EventContentCreator.create_completion(
+                    "200", "reset_completed", result).to_dict()
+            )
+            logger.info(f"Chat reset (event file id: {file_id}) completed successfully")
+        except Exception as e:
+            logger.error(f"Error resetting chat {file_id}: {str(e)}")
+            logger.exception(e)
+            get_event_manager(event_file).write_error(
+                EventContentCreator.create_error(error_code="500", error_message=str(e), details={}).to_dict()
+            )
+    
+    # 创建并启动线程
+    thread = Thread(target=run_reset_in_thread)
+    thread.daemon = True  # 设置为守护线程
+    thread.start()
+    
+    logger.info(f"Started chat reset {file_id} in background thread")
+    return {"event_file_id": file_id, "session_id": request.session_id}
+
 @router.post("/api/chat-command/cancel")
 async def cancel_task(request: CancelTaskRequest, project_path: str = Depends(get_project_path)):
     """

auto_coder_web/routers/code_editor_tabs_router.py

@@ -0,0 +1,191 @@
+import os
+import json
+import aiofiles
+from fastapi import APIRouter, HTTPException, Request, Depends
+from pydantic import BaseModel
+from pathlib import Path
+from typing import List, Optional
+
+router = APIRouter()
+
+# 定义数据模型
+class EditorTab(BaseModel):
+    path: str
+    label: str
+    isActive: bool = False
+
+class EditorTabsConfig(BaseModel):
+    tabs: List[EditorTab] = []
+    activeTabPath: Optional[str] = None
+
+async def get_project_path(request: Request) -> str:
+    """从FastAPI请求上下文中获取项目路径"""
+    return request.app.state.project_path
+
+async def get_config_path(project_path: str) -> Path:
+    """获取代码编辑器标签页配置文件路径"""
+    config_path = Path(project_path) / ".auto-coder" / "auto-coder.web" / "editor_tabs.json"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    return config_path
+
+async def load_config(config_path: Path) -> EditorTabsConfig:
+    """加载代码编辑器标签页配置"""
+    if not config_path.exists():
+        return EditorTabsConfig()
+    
+    try:
+        async with aiofiles.open(config_path, mode='r', encoding='utf-8') as f:
+            content = await f.read()
+            config_data = json.loads(content)
+            return EditorTabsConfig(**config_data)
+    except FileNotFoundError:
+        return EditorTabsConfig()
+    except json.JSONDecodeError:
+        # 处理配置文件损坏或为空的情况
+        return EditorTabsConfig()
+
+async def save_config(config: EditorTabsConfig, config_path: Path):
+    """保存代码编辑器标签页配置"""
+    async with aiofiles.open(config_path, mode='w', encoding='utf-8') as f:
+        await f.write(json.dumps(config.dict(), indent=2, ensure_ascii=False))
+
+# 获取所有编辑器标签页
+@router.get("/api/editor/tabs")
+async def get_editor_tabs(request: Request):
+    """获取所有代码编辑器标签页配置"""
+    project_path = await get_project_path(request)
+    config_path = await get_config_path(project_path)
+    config = await load_config(config_path)
+    return config.dict()
+
+# 更新编辑器标签页列表
+@router.put("/api/editor/tabs")
+async def update_editor_tabs(
+    tabs: List[EditorTab],
+    request: Request
+):
+    """更新代码编辑器标签页列表"""
+    project_path = await get_project_path(request)
+    config_path = await get_config_path(project_path)
+    config = await load_config(config_path)
+    
+    config.tabs = tabs
+    
+    # 更新活跃标签
+    active_tabs = [tab for tab in tabs if tab.isActive]
+    if active_tabs:
+        config.activeTabPath = active_tabs[0].path
+    elif tabs:
+        config.activeTabPath = tabs[0].path
+    else:
+        config.activeTabPath = None
+        
+    await save_config(config, config_path)
+    return config.dict()
+
+# 更新当前活跃标签
+@router.put("/api/editor/active-tab")
+async def update_active_tab(
+    active_tab: dict,
+    request: Request
+):
+    """更新当前活跃的代码编辑器标签页"""
+    tab_path = active_tab.get("path")
+    if not tab_path:
+        raise HTTPException(status_code=400, detail="必须提供标签页路径")
+    
+    project_path = await get_project_path(request)
+    config_path = await get_config_path(project_path)
+    config = await load_config(config_path)
+    
+    # 确保指定的标签页存在
+    tab_paths = [tab.path for tab in config.tabs]
+    if tab_path not in tab_paths:
+        # 如果标签不存在，添加一个新标签
+        new_tab = EditorTab(
+            path=tab_path,
+            label=tab_path.split('/')[-1],
+            isActive=True
+        )
+        config.tabs.append(new_tab)
+    else:
+        # 更新标签的活跃状态
+        config.tabs = [
+            EditorTab(
+                path=tab.path,
+                label=tab.label,
+                isActive=(tab.path == tab_path)
+            )
+            for tab in config.tabs
+        ]
+    
+    config.activeTabPath = tab_path
+    await save_config(config, config_path)
+    return {"activeTabPath": tab_path}
+
+# 添加新标签页
+@router.post("/api/editor/tabs")
+async def add_editor_tab(
+    tab: EditorTab,
+    request: Request
+):
+    """添加新的代码编辑器标签页"""
+    if not tab.path:
+        raise HTTPException(status_code=400, detail="标签页必须包含路径")
+    
+    project_path = await get_project_path(request)
+    config_path = await get_config_path(project_path)
+    config = await load_config(config_path)
+    
+    # 检查路径是否已存在
+    existing_paths = [existing_tab.path for existing_tab in config.tabs]
+    if tab.path in existing_paths:
+        # 如果标签已存在，只更新活跃状态
+        config.tabs = [
+            EditorTab(
+                path=t.path,
+                label=t.label,
+                isActive=(t.path == tab.path)
+            )
+            for t in config.tabs
+        ]
+    else:
+        # 添加新标签并设置为活跃
+        for t in config.tabs:
+            t.isActive = False
+        config.tabs.append(tab)
+    
+    if tab.isActive:
+        config.activeTabPath = tab.path
+    
+    await save_config(config, config_path)
+    return tab.dict()
+
+# 删除标签页
+@router.delete("/api/editor/tabs/{tab_path}")
+async def delete_editor_tab(
+    tab_path: str,
+    request: Request
+):
+    """删除指定的代码编辑器标签页"""
+    project_path = await get_project_path(request)
+    config_path = await get_config_path(project_path)
+    config = await load_config(config_path)
+    
+    # 查找并删除标签页
+    initial_length = len(config.tabs)
+    config.tabs = [tab for tab in config.tabs if tab.path != tab_path]
+    
+    if len(config.tabs) == initial_length:
+        raise HTTPException(status_code=404, detail=f"标签页路径 '{tab_path}' 不存在")
+    
+    # 如果删除的是当前活跃标签，切换到第一个标签
+    if config.activeTabPath == tab_path:
+        if config.tabs:
+            config.activeTabPath = config.tabs[0].path
+            config.tabs[0].isActive = True
+        else:
+            config.activeTabPath = None
+    
+    await save_config(config, config_path)
+    return {"success": True, "activeTabPath": config.activeTabPath}

auto_coder_web/routers/coding_router.py

@@ -16,6 +16,9 @@ from byzerllm.utils.langutil import asyncfy_with_semaphore
 from autocoder.common.global_cancel import global_cancel, CancelRequestedException 
 from loguru import logger
 import byzerllm
+# 导入聊天会话和聊天列表管理器
+from auto_coder_web.common_router.chat_session_manager import read_session_name_sync
+from auto_coder_web.common_router.chat_list_manager import get_chat_list_sync
 
 router = APIRouter()
 
@@ -24,6 +27,7 @@ cancel_thread_pool = ThreadPoolExecutor(max_workers=5)
 
 class CodingCommandRequest(BaseModel):
     command: str
+    panel_id: Optional[str] = None
 
 class EventPollRequest(BaseModel):
     event_file_id: str    
@@ -92,36 +96,34 @@ async def coding_command(request: CodingCommandRequest, project_path: str = Depe
             global_cancel.register_token(event_file)
 
             # 获取当前会话名称
-            current_session_file = os.path.join(project_path, ".auto-coder", "auto-coder.web", "current-session.json")
-            current_session_name = ""
-            if os.path.exists(current_session_file):
-                try:
-                    with open(current_session_file, 'r',encoding="utf-8") as f:
-                        session_data = json.load(f)
-                        current_session_name = session_data.get("session_name", "")
-                except Exception as e:
-                    logger.error(f"Error reading current session: {str(e)}")
+            panel_id = request.panel_id or ""
+            try:
+                # 使用同步版本的会话管理函数，传递panel_id参数
+                current_session_name = read_session_name_sync(project_path, panel_id)
+            except Exception as e:
+                logger.error(f"Error reading current session: {str(e)}")
+                current_session_name = ""
             
             # 获取历史消息
             messages = []
             if current_session_name:
-                chat_list_file = os.path.join(project_path, ".auto-coder", "auto-coder.web", "chat-lists", f"{current_session_name}.json")
-                if os.path.exists(chat_list_file):
-                    try:
-                        with open(chat_list_file, 'r', encoding="utf-8") as f:
-                            chat_data = json.load(f)
-                            # 从聊天历史中提取消息
-                            for msg in chat_data.get("messages", []):
-                                # 只保留用户和中间结果信息
-                                if msg.get("type","") not in ["USER_RESPONSE","RESULT"]:
-                                    continue     
-
-                                if msg.get("contentType","") in ["token_stat"]:
-                                    continue                            
-                                
-                                messages.append(msg)
-                    except Exception as e:
-                        logger.error(f"Error reading chat history: {str(e)}")
+                try:
+                    # 使用同步版本的聊天列表管理函数
+                    logger.info(f"Loading chat history for session: {current_session_name}")
+                    chat_data = get_chat_list_sync(project_path, current_session_name)
+                    
+                    # 从聊天历史中提取消息
+                    for msg in chat_data.get("messages", []):
+                        # 只保留用户和中间结果信息
+                        if msg.get("type","") not in ["USER_RESPONSE","RESULT"]:
+                            continue     
+
+                        if msg.get("contentType","") in ["token_stat"]:
+                            continue                            
+                        
+                        messages.append(msg)
+                except Exception as e:
+                    logger.error(f"Error reading chat history: {str(e)}")
             
             # 构建提示信息
             prompt_text = request.command