auto-coder-web 0.1.92__py3-none-any.whl → 0.1.94__py3-none-any.whl

auto_coder_web/common_router/chat_list_manager.py

@@ -0,0 +1,194 @@
+import os
+import json
+import asyncio
+import aiofiles
+from typing import List, Dict, Any, Tuple
+from loguru import logger
+
+def _get_chat_lists_dir(project_path: str) -> str:
+    """获取聊天列表目录的路径，并确保目录存在"""
+    chat_lists_dir = os.path.join(project_path, ".auto-coder", "auto-coder.web", "chat-lists")
+    os.makedirs(chat_lists_dir, exist_ok=True)
+    return chat_lists_dir
+
+def _get_chat_list_file_path(project_path: str, name: str) -> str:
+    """获取特定聊天列表文件的完整路径"""
+    chat_lists_dir = _get_chat_lists_dir(project_path)
+    return os.path.join(chat_lists_dir, f"{name}.json")
+
+async def save_chat_list(project_path: str, name: str, messages: List[Dict[str, Any]]) -> None:
+    """
+    保存聊天列表到文件
+    
+    Args:
+        project_path: 项目路径
+        name: 聊天列表名称
+        messages: 聊天消息列表
+        
+    Raises:
+        Exception: 如果保存失败
+    """
+    file_path = _get_chat_list_file_path(project_path, name)
+    try:
+        async with aiofiles.open(file_path, 'w') as f:
+            await f.write(json.dumps({"messages": messages}, indent=2, ensure_ascii=False))
+    except Exception as e:
+        logger.error(f"Error saving chat list {name}: {str(e)}")
+        raise e
+
+async def get_chat_lists(project_path: str) -> List[str]:
+    """
+    获取所有聊天列表的名称，按修改时间倒序排列（最新的在前）
+    
+    Args:
+        project_path: 项目路径
+        
+    Returns:
+        聊天列表名称列表
+        
+    Raises:
+        Exception: 如果获取列表失败
+    """
+    chat_lists_dir = _get_chat_lists_dir(project_path)
+    
+    try:
+        # 获取文件及其修改时间
+        chat_lists = []
+        files = await asyncio.to_thread(os.listdir, chat_lists_dir)
+        for file in files:
+            if file.endswith('.json'):
+                file_path = os.path.join(chat_lists_dir, file)
+                mod_time = os.path.getmtime(file_path)
+                # 存储(名称, 修改时间)的元组
+                chat_lists.append((file[:-5], mod_time))
+
+        # 按修改时间倒序排序（最新的在前）
+        chat_lists.sort(key=lambda x: x[1], reverse=True)
+
+        # 只返回聊天列表名称
+        return [name for name, _ in chat_lists]
+    except Exception as e:
+        logger.error(f"Error getting chat lists: {str(e)}")
+        raise e
+
+async def get_chat_list(project_path: str, name: str) -> Dict[str, Any]:
+    """
+    获取特定聊天列表的内容
+    
+    Args:
+        project_path: 项目路径
+        name: 聊天列表名称
+        
+    Returns:
+        聊天列表内容
+        
+    Raises:
+        FileNotFoundError: 如果聊天列表不存在
+        Exception: 如果读取失败
+    """
+    file_path = _get_chat_list_file_path(project_path, name)
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Chat list {name} not found")
+        
+    try:
+        async with aiofiles.open(file_path, 'r') as f:
+            content = await f.read()
+            return json.loads(content)
+    except json.JSONDecodeError as e:
+        logger.error(f"Invalid JSON in chat list {name}: {str(e)}")
+        raise Exception(f"Invalid JSON in chat list file: {str(e)}")
+    except Exception as e:
+        logger.error(f"Error reading chat list {name}: {str(e)}")
+        raise e
+
+def get_chat_list_sync(project_path: str, name: str) -> Dict[str, Any]:
+    """
+    获取特定聊天列表的内容（同步版本）
+    
+    Args:
+        project_path: 项目路径
+        name: 聊天列表名称
+        
+    Returns:
+        聊天列表内容
+        
+    Raises:
+        FileNotFoundError: 如果聊天列表不存在
+        Exception: 如果读取失败
+    """
+    file_path = _get_chat_list_file_path(project_path, name)
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Chat list {name} not found")
+        
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+            return json.loads(content)
+    except json.JSONDecodeError as e:
+        logger.error(f"Invalid JSON in chat list {name}: {str(e)}")
+        raise Exception(f"Invalid JSON in chat list file: {str(e)}")
+    except Exception as e:
+        logger.error(f"Error reading chat list {name}: {str(e)}")
+        raise e
+
+async def delete_chat_list(project_path: str, name: str) -> None:
+    """
+    删除聊天列表
+    
+    Args:
+        project_path: 项目路径
+        name: 聊天列表名称
+        
+    Raises:
+        FileNotFoundError: 如果聊天列表不存在
+        Exception: 如果删除失败
+    """
+    file_path = _get_chat_list_file_path(project_path, name)
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Chat list {name} not found")
+        
+    try:
+        os.remove(file_path)
+    except Exception as e:
+        logger.error(f"Error deleting chat list {name}: {str(e)}")
+        raise e
+
+async def rename_chat_list(project_path: str, old_name: str, new_name: str) -> None:
+    """
+    重命名聊天列表
+    
+    Args:
+        project_path: 项目路径
+        old_name: 旧的聊天列表名称
+        new_name: 新的聊天列表名称
+        
+    Raises:
+        FileNotFoundError: 如果原聊天列表不存在
+        FileExistsError: 如果新名称的聊天列表已存在
+        Exception: 如果重命名失败
+    """
+    old_file_path = _get_chat_list_file_path(project_path, old_name)
+    new_file_path = _get_chat_list_file_path(project_path, new_name)
+    
+    # 检查旧文件是否存在
+    if not os.path.exists(old_file_path):
+        raise FileNotFoundError(f"Chat list {old_name} not found")
+    
+    # 检查新文件名是否已存在
+    if os.path.exists(new_file_path):
+        raise FileExistsError(f"Chat list with name {new_name} already exists")
+    
+    try:
+        # 读取旧文件内容
+        async with aiofiles.open(old_file_path, 'r') as f:
+            content = await f.read()
+        
+        # 写入新文件
+        async with aiofiles.open(new_file_path, 'w') as f:
+            await f.write(content)
+        
+        # 删除旧文件
+        os.remove(old_file_path)
+    except Exception as e:
+        logger.error(f"Error renaming chat list from {old_name} to {new_name}: {str(e)}")
+        raise e 

auto_coder_web/common_router/chat_list_router.py

@@ -5,9 +5,15 @@ import aiofiles
 from auto_coder_web.types import ChatList
 from pydantic import BaseModel
 import asyncio
+from loguru import logger
+# 导入会话管理函数
+from .chat_session_manager import read_session_name, write_session_name
+# 导入聊天列表管理函数
+from .chat_list_manager import save_chat_list, get_chat_lists, get_chat_list, delete_chat_list, rename_chat_list
 
 class SessionNameRequest(BaseModel):
     session_name: str
+    panel_id: str = ""  # 添加panel_id字段，默认为空字符串
 
 
 class RenameChatListRequest(BaseModel):
@@ -25,103 +31,65 @@ router = APIRouter()
 
 
 @router.post("/api/chat-lists/save")
-async def save_chat_list(chat_list: ChatList, project_path: str = Depends(get_project_path)):
+async def save_chat_list_endpoint(chat_list: ChatList, project_path: str = Depends(get_project_path)):
     try:
-        chat_lists_dir = os.path.join(project_path,
-                                      ".auto-coder", "auto-coder.web", "chat-lists")
-        os.makedirs(chat_lists_dir, exist_ok=True)
-
-        file_path = os.path.join(chat_lists_dir, f"{chat_list.name}.json")
-        async with aiofiles.open(file_path, 'w') as f:
-            await f.write(json.dumps({"messages": chat_list.messages}, indent=2, ensure_ascii=False))
+        # 调用管理模块保存聊天列表
+        await save_chat_list(project_path, chat_list.name, chat_list.messages)
         return {"status": "success", "message": f"Chat list {chat_list.name} saved successfully"}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 
 @router.get("/api/chat-lists")
-async def get_chat_lists(project_path: str = Depends(get_project_path)):
+async def get_chat_lists_endpoint(project_path: str = Depends(get_project_path)):
     try:
-        chat_lists_dir = os.path.join(
-            project_path, ".auto-coder", "auto-coder.web", "chat-lists")
-        os.makedirs(chat_lists_dir, exist_ok=True)
-
-        # Get files with their modification times
-        chat_lists = []
-        files = await asyncio.to_thread(os.listdir, chat_lists_dir)
-        for file in files:
-            if file.endswith('.json'):
-                file_path = os.path.join(chat_lists_dir, file)
-                mod_time = os.path.getmtime(file_path)
-                # Store tuple of (name, mod_time)
-                chat_lists.append((file[:-5], mod_time))
-
-        # Sort by modification time (newest first)
-        chat_lists.sort(key=lambda x: x[1], reverse=True)
-
-        # Return only the chat list names
-        return {"chat_lists": [name for name, _ in chat_lists]}
+        # 调用管理模块获取聊天列表
+        chat_lists = await get_chat_lists(project_path)
+        return {"chat_lists": chat_lists}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 
 @router.get("/api/chat-lists/{name}")
-async def get_chat_list(name: str, project_path: str = Depends(get_project_path)):
+async def get_chat_list_endpoint(name: str, project_path: str = Depends(get_project_path)):
     try:
-        file_path = os.path.join(
-            project_path, ".auto-coder", "auto-coder.web", "chat-lists", f"{name}.json")
-        if not os.path.exists(file_path):
-            raise HTTPException(
-                status_code=404, detail=f"Chat list {name} not found")
-
-        async with aiofiles.open(file_path, 'r') as f:
-            content = await f.read()
-            return json.loads(content)
+        # 调用管理模块获取特定聊天列表
+        return await get_chat_list(project_path, name)
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail=f"Chat list {name} not found")
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 
 @router.delete("/api/chat-lists/{name}")
-async def delete_chat_list(name: str, project_path: str = Depends(get_project_path)):
+async def delete_chat_list_endpoint(name: str, project_path: str = Depends(get_project_path)):
     try:
-        file_path = os.path.join(
-            project_path, ".auto-coder", "auto-coder.web", "chat-lists", f"{name}.json")
-        if not os.path.exists(file_path):
-            raise HTTPException(
-                status_code=404, detail=f"Chat list {name} not found")
-
-        os.remove(file_path)
+        # 调用管理模块删除聊天列表
+        await delete_chat_list(project_path, name)
         return {"status": "success", "message": f"Chat list {name} deleted successfully"}
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail=f"Chat list {name} not found")
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 
 @router.get("/api/chat-session/name")
-async def get_current_session_name(project_path: str = Depends(get_project_path)):
+async def get_current_session_name(panel_id: str = "", project_path: str = Depends(get_project_path)):
     """
     获取当前会话名称
+    
+    Args:
+        panel_id: 可选的面板ID，用于区分不同的聊天面板
+        project_path: 项目路径
     """
     try:
-        # 创建存储会话信息的目录
-        session_dir = os.path.join(project_path, ".auto-coder", "auto-coder.web")
-        os.makedirs(session_dir, exist_ok=True)
-        
-        # 会话信息文件路径
-        session_file = os.path.join(session_dir, "current-session.json")
-        
-        # 如果文件不存在，返回空会话名称
-        if not os.path.exists(session_file):
-            return {"session_name": ""}
-        
-        # 读取当前会话信息
-        async with aiofiles.open(session_file, 'r') as f:
-            content = await f.read()
-            session_data = json.loads(content)
-            return {"session_name": session_data.get("session_name", "")}
+        # 调用新的函数读取会话名称
+        session_name = await read_session_name(project_path, panel_id)
+        return {"session_name": session_name}
             
     except Exception as e:
-        # 如果发生错误，记录错误但返回空会话名
-        print(f"Error getting current session name: {str(e)}")
+        # 如果发生错误，记录错误但返回空会话名 (read_session_name内部已处理部分错误)
+        logger.error(f"Error in get_current_session_name endpoint: {str(e)}")
         return {"session_name": ""}
 
 
@@ -129,20 +97,14 @@ async def get_current_session_name(project_path: str = Depends(get_project_path)
 async def set_current_session_name(request: SessionNameRequest, project_path: str = Depends(get_project_path)):
     """
     设置当前会话名称
+    
+    Args:
+        request: 包含会话名称和可选面板ID的请求
+        project_path: 项目路径
     """
     try:
-        # 创建存储会话信息的目录
-        session_dir = os.path.join(project_path, ".auto-coder", "auto-coder.web")
-        os.makedirs(session_dir, exist_ok=True)
-        
-        # 会话信息文件路径
-        session_file = os.path.join(session_dir, "current-session.json")
-        
-        # 保存当前会话信息
-        session_data = {"session_name": request.session_name}
-        async with aiofiles.open(session_file, 'w') as f:
-            await f.write(json.dumps(session_data, indent=2, ensure_ascii=False))
-            
+        # 调用新的函数写入会话名称
+        await write_session_name(project_path, request.session_name, request.panel_id)
         return {"status": "success", "message": "Current session name updated"}
             
     except Exception as e:
@@ -150,53 +112,31 @@ async def set_current_session_name(request: SessionNameRequest, project_path: st
 
 
 @router.post("/api/chat-lists/rename")
-async def rename_chat_list(request: RenameChatListRequest, project_path: str = Depends(get_project_path)):
+async def rename_chat_list_endpoint(request: RenameChatListRequest, project_path: str = Depends(get_project_path)):
     """
     重命名聊天列表
     
     将现有聊天列表从旧名称重命名为新名称
     """
     try:
-        chat_lists_dir = os.path.join(project_path, ".auto-coder", "auto-coder.web", "chat-lists")
-        old_file_path = os.path.join(chat_lists_dir, f"{request.old_name}.json")
-        new_file_path = os.path.join(chat_lists_dir, f"{request.new_name}.json")
-        
-        # 检查旧文件是否存在
-        if not os.path.exists(old_file_path):
-            raise HTTPException(status_code=404, detail=f"Chat list {request.old_name} not found")
-        
-        # 检查新文件名是否已存在
-        if os.path.exists(new_file_path):
-            raise HTTPException(status_code=409, detail=f"Chat list with name {request.new_name} already exists")
-        
-        # 读取旧文件内容
-        async with aiofiles.open(old_file_path, 'r') as f:
-            content = await f.read()
-        
-        # 写入新文件
-        async with aiofiles.open(new_file_path, 'w') as f:
-            await f.write(content)
-        
-        # 删除旧文件
-        os.remove(old_file_path)
+        # 调用管理模块重命名聊天列表
+        await rename_chat_list(project_path, request.old_name, request.new_name)
         
         # 如果当前会话名称是旧名称，则更新为新名称
-        session_file = os.path.join(project_path, ".auto-coder", "auto-coder.web", "current-session.json")
-        if os.path.exists(session_file):
-            try:
-                async with aiofiles.open(session_file, 'r') as f:
-                    session_content = await f.read()
-                    session_data = json.loads(session_content)
-                    
-                if session_data.get("session_name") == request.old_name:
-                    session_data["session_name"] = request.new_name
-                    async with aiofiles.open(session_file, 'w') as f:
-                        await f.write(json.dumps(session_data, indent=2, ensure_ascii=False))
-            except Exception as e:
-                print(f"Error updating current session name: {str(e)}")
+        # 注意：这里只更新默认的会话文件（panel_id=""）
+        # 如果需要根据panel_id更新所有相关会话文件，逻辑会更复杂
+        try:
+            current_session_name = await read_session_name(project_path, panel_id="") # P读取默认会话
+            if current_session_name == request.old_name:
+                await write_session_name(project_path, request.new_name, panel_id="") # 更新默认会话
+        except Exception as e:
+            # 记录错误，但不影响重命名操作的主要流程
+            logger.error(f"Error updating default current session name during rename: {str(e)}")
         
         return {"status": "success", "message": f"Chat list renamed from {request.old_name} to {request.new_name}"}
-    except HTTPException:
-        raise
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail=f"Chat list {request.old_name} not found")
+    except FileExistsError:
+        raise HTTPException(status_code=409, detail=f"Chat list with name {request.new_name} already exists")
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Failed to rename chat list: {str(e)}")

auto_coder_web/common_router/chat_session_manager.py

@@ -0,0 +1,111 @@
+import os
+import json
+import aiofiles
+from loguru import logger
+
+def _get_session_file_path(project_path: str, panel_id: str = "") -> str:
+    """获取会话信息文件的完整路径"""
+    session_dir = os.path.join(project_path, ".auto-coder", "auto-coder.web")
+    os.makedirs(session_dir, exist_ok=True)
+    file_name = "current-session.json" if not panel_id else f"current-session-{panel_id}.json"
+    return os.path.join(session_dir, file_name)
+
+async def read_session_name(project_path: str, panel_id: str = "") -> str:
+    """
+    从文件读取当前会话名称
+    
+    Args:
+        project_path: 项目路径
+        panel_id: 可选的面板ID
+
+    Returns:
+        当前会话名称，如果文件不存在或出错则返回空字符串
+    """
+    session_file = _get_session_file_path(project_path, panel_id)
+    
+    if not os.path.exists(session_file):
+        return ""
+        
+    try:
+        async with aiofiles.open(session_file, 'r') as f:
+            content = await f.read()
+            session_data = json.loads(content)
+            return session_data.get("session_name", "")
+    except Exception as e:
+        logger.error(f"Error reading session name from {session_file}: {str(e)}")
+        return ""
+
+def read_session_name_sync(project_path: str, panel_id: str = "") -> str:
+    """
+    从文件读取当前会话名称（同步版本）
+    
+    Args:
+        project_path: 项目路径
+        panel_id: 可选的面板ID
+
+    Returns:
+        当前会话名称，如果文件不存在或出错则返回空字符串
+    """
+    session_file = _get_session_file_path(project_path, panel_id)
+    
+    if not os.path.exists(session_file):
+        return ""
+        
+    try:
+        with open(session_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+            session_data = json.loads(content)
+            return session_data.get("session_name", "")
+    except Exception as e:
+        logger.error(f"Error reading session name from {session_file}: {str(e)}")
+        return ""
+
+async def write_session_name(project_path: str, session_name: str, panel_id: str = ""):
+    """
+    将当前会话名称写入文件
+    
+    Args:
+        project_path: 项目路径
+        session_name: 要写入的会话名称
+        panel_id: 可选的面板ID
+
+    Raises:
+        Exception: 如果写入文件失败
+    """
+    session_file = _get_session_file_path(project_path, panel_id)
+    
+    session_data = {
+        "session_name": session_name,
+        "panel_id": panel_id
+    }
+    try:
+        async with aiofiles.open(session_file, 'w') as f:
+            await f.write(json.dumps(session_data, indent=2, ensure_ascii=False))
+    except Exception as e:
+        logger.error(f"Error writing session name to {session_file}: {str(e)}")
+        raise e
+
+def write_session_name_sync(project_path: str, session_name: str, panel_id: str = ""):
+    """
+    将当前会话名称写入文件（同步版本）
+    
+    Args:
+        project_path: 项目路径
+        session_name: 要写入的会话名称
+        panel_id: 可选的面板ID
+
+    Raises:
+        Exception: 如果写入文件失败
+    """
+    session_file = _get_session_file_path(project_path, panel_id)
+    
+    session_data = {
+        "session_name": session_name,
+        "panel_id": panel_id
+    }
+    try:
+        with open(session_file, 'w', encoding='utf-8') as f:
+            f.write(json.dumps(session_data, indent=2, ensure_ascii=False))
+    except Exception as e:
+        logger.error(f"Error writing session name to {session_file}: {str(e)}")
+        raise e 

auto_coder_web/common_router/file_group_router.py

@@ -4,8 +4,10 @@ from fastapi import APIRouter, Request, HTTPException, Depends
 from autocoder.agent.auto_filegroup import AutoFileGroup
 from autocoder.utils import operate_config_api
 from autocoder.auto_coder_runner import get_memory,save_memory, load_memory
-import json
 import os
+from autocoder.rag.token_counter import count_tokens
+import aiofiles
+from loguru import logger
 
 router = APIRouter()
 
@@ -145,6 +147,31 @@ async def auto_create_groups(
         raise HTTPException(status_code=500, detail=str(e))
 
 
+async def count_tokens_from_file(file_path: str) -> int:
+    """异步计算文件的token数
+    
+    Args:
+        file_path: 文件的绝对路径
+        
+    Returns:
+        int: token数量，出错时返回0
+    """
+    try:
+        if not os.path.exists(file_path):
+            logger.warning(f"文件不存在: {file_path}")
+            return 0
+            
+        logger.info(f"计算文件token: {file_path}")
+        async with aiofiles.open(file_path, 'r', encoding='utf-8') as f:
+            content = await f.read()
+        
+        file_tokens = count_tokens(content)
+        return file_tokens if file_tokens > 0 else 0
+    except Exception as e:
+        logger.error(f"读取或计算文件token出错: {file_path}, 错误: {str(e)}")
+        return 0
+
+
 @router.post("/api/file-groups/switch")
 async def switch_file_groups(
     request: Request,
@@ -156,12 +183,38 @@ async def switch_file_groups(
     
     # Convert relative file paths to absolute paths
     absolute_file_paths = []
+    total_tokens = 0
+    
     for file_path in file_paths:
         absolute_path = os.path.join(project_path, file_path)
         absolute_file_paths.append(absolute_path)
     
+    # 计算所有文件的tokens
+    token_tasks = []
+    
+    # 收集组里的文件
+    for group_name in group_names:
+        memory = get_memory()
+        files = memory["current_files"]["groups"].get(group_name, [])
+        for file_path in files:
+            token_tasks.append(count_tokens_from_file(file_path))
+    
+    # 收集额外的文件
+    for file_path in absolute_file_paths:
+        token_tasks.append(count_tokens_from_file(file_path))
+    
+    # 异步等待所有token计算任务完成
+    if token_tasks:
+        token_results = await asyncio.gather(*token_tasks)
+        total_tokens = sum(token_results)
+    
     await asyncio.to_thread(_switch_groups, group_names, absolute_file_paths)
-    return {"status": "success", "message": f"Switched to groups: {group_names} and additional files"}
+    return {
+        "status": "success", 
+        "message": f"Switched to groups: {group_names} and additional files",
+        "total_tokens": total_tokens,
+        "absolute_file_paths": absolute_file_paths
+    }
 
 
 @router.delete("/api/file-groups/{name}")

auto_coder_web/proxy.py

@@ -19,14 +19,13 @@ import sys
 from auto_coder_web.terminal import terminal_manager
 from autocoder.common import AutoCoderArgs
 from auto_coder_web.auto_coder_runner_wrapper import AutoCoderRunnerWrapper
-from auto_coder_web.routers import todo_router, settings_router, auto_router, commit_router, chat_router, coding_router, index_router, config_router, upload_router, rag_router, editable_preview_router, mcp_router, direct_chat_router, rules_router
+from auto_coder_web.routers import todo_router, settings_router, auto_router, commit_router, chat_router, coding_router, index_router, config_router, upload_router, rag_router, editable_preview_router, mcp_router, direct_chat_router, rules_router, chat_panels_router, code_editor_tabs_router
 from auto_coder_web.expert_routers import history_router
 from auto_coder_web.common_router import completions_router, file_router, auto_coder_conf_router, chat_list_router, file_group_router, model_router, compiler_router
 from auto_coder_web.common_router import active_context_router
 from rich.console import Console
 from loguru import logger
 from auto_coder_web.lang import get_message
-from auto_coder_web.file_cacher.filecacher import FileCacher
 
 class ProxyServer:
     def __init__(self, project_path: str, quick: bool = False, product_mode: str = "pro"):    
@@ -111,6 +110,8 @@ class ProxyServer:
         self.app.include_router(active_context_router.router)
         self.app.include_router(direct_chat_router.router)
         self.app.include_router(rules_router.router)
+        self.app.include_router(chat_panels_router.router)
+        self.app.include_router(code_editor_tabs_router.router)
 
         @self.app.on_event("shutdown")
         async def shutdown_event():