neuro-simulator 0.0.3__py3-none-any.whl → 0.1.2__py3-none-any.whl

neuro_simulator/letta.py

@@ -2,60 +2,86 @@
 from letta_client import Letta, MessageCreate, TextContent, LlmConfig, AssistantMessage
 from fastapi import HTTPException, status
 from .config import config_manager
+import asyncio
+from typing import Union
 
-# 初始化 Letta 客户端
-letta_client: Letta | None = None
-try:
-    if not config_manager.settings.api_keys.letta_token:
-        raise ValueError("LETTA_API_TOKEN is not set. Cannot initialize Letta client.")
-    
-    # 使用 settings 对象进行配置
-    client_args = {'token': config_manager.settings.api_keys.letta_token}
-    if config_manager.settings.api_keys.letta_base_url:
-        client_args['base_url'] = config_manager.settings.api_keys.letta_base_url
-        print(f"Letta client is being initialized for self-hosted URL: {config_manager.settings.api_keys.letta_base_url}")
-    else:
-        print("Letta client is being initialized for Letta Cloud.")
-
-    letta_client = Letta(**client_args)
-
-    if config_manager.settings.api_keys.neuro_agent_id:
-        try:
-            agent_data = letta_client.agents.retrieve(agent_id=config_manager.settings.api_keys.neuro_agent_id)
-            print(f"成功获取 Letta Agent 详情，ID: {agent_data.id}")
-            llm_model_info = "N/A"
-            if hasattr(agent_data, 'model') and agent_data.model:
-                llm_model_info = agent_data.model
-            elif agent_data.llm_config:
-                if isinstance(agent_data.llm_config, LlmConfig):
-                    llm_config_dict = agent_data.llm_config.model_dump() if hasattr(agent_data.llm_config, 'model_dump') else agent_data.llm_config.__dict__
-                    llm_model_info = llm_config_dict.get('model_name') or llm_config_dict.get('name') or llm_config_dict.get('model')
-                if not llm_model_info:
-                    llm_model_info = str(agent_data.llm_config)
-            print(f"  -> Agent 名称: {agent_data.name}")
-            print(f"  -> LLM 模型: {llm_model_info}")
-
-        except Exception as e:
-            error_msg = f"错误: 无法获取 Neuro Letta Agent (ID: {config_manager.settings.api_keys.neuro_agent_id})。请确保 ID 正确，且服务可访问。详情: {e}"
-            print(error_msg)
-            raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=error_msg)
-except Exception as e:
-    print(f"初始化 Letta 客户端失败: {e}")
-    letta_client = None
+# Global variables
+letta_client: Union[Letta, None] = None
+
+def initialize_letta_client():
+    """Initializes the Letta client if not already initialized."""
+    global letta_client
+    if letta_client:
+        return
+
+    try:
+        if not config_manager.settings.api_keys.letta_token:
+            raise ValueError("LETTA_API_TOKEN is not set. Cannot initialize Letta client.")
+        
+        client_args = {'token': config_manager.settings.api_keys.letta_token}
+        if config_manager.settings.api_keys.letta_base_url:
+            client_args['base_url'] = config_manager.settings.api_keys.letta_base_url
+            print(f"Letta client is being initialized for self-hosted URL: {config_manager.settings.api_keys.letta_base_url}")
+        else:
+            print("Letta client is being initialized for Letta Cloud.")
+
+        letta_client = Letta(**client_args)
+
+        if config_manager.settings.api_keys.neuro_agent_id:
+            try:
+                agent_data = letta_client.agents.retrieve(agent_id=config_manager.settings.api_keys.neuro_agent_id)
+                print(f"成功获取 Letta Agent 详情，ID: {agent_data.id}")
+                llm_model_info = "N/A"
+                if hasattr(agent_data, 'model') and agent_data.model:
+                    llm_model_info = agent_data.model
+                elif agent_data.llm_config:
+                    if isinstance(agent_data.llm_config, LlmConfig):
+                        llm_config_dict = agent_data.llm_config.model_dump() if hasattr(agent_data.llm_config, 'model_dump') else agent_data.llm_config.__dict__
+                        llm_model_info = llm_config_dict.get('model_name') or llm_config_dict.get('name') or llm_config_dict.get('model')
+                    if not llm_model_info:
+                        llm_model_info = str(agent_data.llm_config)
+                print(f"  -> Agent 名称: {agent_data.name}")
+                print(f"  -> LLM 模型: {llm_model_info}")
+            except Exception as e:
+                error_msg = f"错误: 无法获取 Neuro Letta Agent (ID: {config_manager.settings.api_keys.neuro_agent_id})。请确保 ID 正确，且服务可访问。详情: {e}"
+                print(error_msg)
+                raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=error_msg)
+    except Exception as e:
+        print(f"初始化 Letta 客户端失败: {e}")
+        letta_client = None
 
 def get_letta_client():
     if letta_client is None: raise ValueError("Letta client is not initialized.")
     return letta_client
 
+async def initialize_agent():
+    """Initialize the appropriate agent based on configuration"""
+    agent_type = config_manager.settings.agent_type
+    
+    if agent_type == "letta":
+        initialize_letta_client()
+        print("Using Letta as the agent")
+    else:
+        print(f"Unknown agent type: {agent_type}. Defaulting to Letta.")
+        initialize_letta_client()
+        
+    return agent_type
+
 async def reset_neuro_agent_memory():
     """
     重置 Agent 的记忆，包括：
     1. 清空所有消息历史记录。
     2. 清空指定的 'conversation_summary' 核心内存块。
     """
+    # Ensure letta client is initialized before using it
+    initialize_letta_client()
+    if letta_client is None:
+        print("Letta client 未初始化，跳过重置。")
+        return
+        
     agent_id = config_manager.settings.api_keys.neuro_agent_id
-    if letta_client is None or not agent_id: 
-        print("Letta client 或 Agent ID 未配置，跳过重置。")
+    if not agent_id: 
+        print("Letta Agent ID 未配置，跳过重置。")
         return
 
     # --- 步骤 1: 重置消息历史记录 (上下文) ---
@@ -87,11 +113,12 @@ async def reset_neuro_agent_memory():
         else:
              print(f"警告: 清空核心记忆块 '{block_label_to_clear}' 失败: {e}。")
 
-
 async def get_neuro_response(chat_messages: list[dict]) -> str:
+    # Ensure letta client is initialized before using it
+    initialize_letta_client()
     if letta_client is None or not config_manager.settings.api_keys.neuro_agent_id:
-        print("警告: Letta client 或 Agent ID 未配置，无法获取响应。")
-        return "我暂时无法回应，请稍后再试。"
+        print("错误: Letta client 或 Agent ID 未配置，无法获取响应。")
+        return "Someone tell Vedal there is a problem with my AI."
 
     if chat_messages:
         injected_chat_lines = [f"{chat['username']}: {chat['text']}" for chat in chat_messages]
@@ -106,7 +133,9 @@ async def get_neuro_response(chat_messages: list[dict]) -> str:
     print(f"正在向 Neuro Agent 发送输入 (包含 {len(chat_messages)} 条消息)..." )
 
     try:
-        response = letta_client.agents.messages.create(
+        # 使用 asyncio.to_thread 在线程池中执行阻塞调用，避免阻塞事件循环
+        response = await asyncio.to_thread(
+            letta_client.agents.messages.create,
             agent_id=config_manager.settings.api_keys.neuro_agent_id,
             messages=[MessageCreate(role="user", content=injected_chat_text)]
         )
@@ -125,7 +154,7 @@ async def get_neuro_response(chat_messages: list[dict]) -> str:
         
         if not ai_full_response_text:
             print(f"警告: 未能从 Letta 响应中解析出有效的文本。响应对象: {response}")
-            return "I seem to be at a loss for words right now."
+            return "Someone tell Vedal there is a problem with my AI."
 
         print(f"成功从 Letta 解析到响应: '{ai_full_response_text[:70]}...'")
         return ai_full_response_text

neuro_simulator/log_handler.py

@@ -1,29 +1,43 @@
 # backend/log_handler.py
 import logging
-import asyncio
 from collections import deque
+from typing import Deque
 
-# 使用 deque 作为有界队列，避免内存无限增长
-log_queue: deque = deque(maxlen=1000)
+# 创建两个独立的、有界限的队列，用于不同来源的日志
+server_log_queue: Deque[str] = deque(maxlen=1000)
+agent_log_queue: Deque[str] = deque(maxlen=1000)
 
 class QueueLogHandler(logging.Handler):
-    """一个将日志记录发送到队列的处理器。"""
+    """一个将日志记录发送到指定队列的处理器。"""
+    def __init__(self, queue: Deque[str]):
+        super().__init__()
+        self.queue = queue
+
     def emit(self, record: logging.LogRecord):
-        # 格式化日志消息
         log_entry = self.format(record)
-        log_queue.append(log_entry)
+        self.queue.append(log_entry)
 
-def configure_logging():
-    """配置全局日志，添加我们的队列处理器。"""
-    queue_handler = QueueLogHandler()
-    # 设置一个你喜欢的日志格式
-    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s', datefmt='%H:%M:%S')
-    queue_handler.setFormatter(formatter)
+def configure_server_logging():
+    """配置服务器（根）日志记录器，将其日志发送到 server_log_queue。"""
+    # 为服务器日志创建一个处理器实例
+    server_queue_handler = QueueLogHandler(server_log_queue)
+    formatter = logging.Formatter('%(asctime)s - [SERVER] - %(levelname)s - %(message)s', datefmt='%H:%M:%S')
+    server_queue_handler.setFormatter(formatter)
     
-    # 获取根 logger 并添加我们的 handler
-    # 这将捕获来自所有模块（fastapi, uvicorn, letta等）的日志
+    # 获取根 logger 并添加 handler
+    # 这将捕获所有未被专门处理的日志（来自fastapi, uvicorn等）
     root_logger = logging.getLogger()
-    root_logger.addHandler(queue_handler)
+    # 清除可能存在的旧handler，以防万一
+    if root_logger.hasHandlers():
+        root_logger.handlers.clear()
+        
+    root_logger.addHandler(server_queue_handler)
     root_logger.setLevel(logging.INFO)
 
-    print("日志系统已配置，将日志输出到内部队列。")
+    # 将 uvicorn 的日志也引导到我们的 handler
+    logging.getLogger("uvicorn.access").handlers = [server_queue_handler]
+    logging.getLogger("uvicorn.error").handlers = [server_queue_handler]
+
+    print("服务器日志系统已配置，将日志输出到 server_log_queue。")
+
+# Agent 的日志配置将会在 agent 模块内部完成，以保持解耦

neuro_simulator/main.py

@@ -24,11 +24,11 @@ from fastapi.security import APIKeyCookie
 # --- 核心模块导入 ---
 from .config import config_manager, AppSettings
 from .process_manager import process_manager
-from .log_handler import configure_logging, log_queue
+from .log_handler import configure_server_logging, server_log_queue, agent_log_queue
 
 # --- 功能模块导入 ---
 from .chatbot import ChatbotManager, get_dynamic_audience_prompt
-from .letta import get_neuro_response, reset_neuro_agent_memory
+# from .letta import get_neuro_response, reset_neuro_agent_memory, initialize_agent # This will be imported dynamically
 from .audio_synthesis import synthesize_audio_segment
 from .stream_chat import (
     add_to_audience_buffer, add_to_neuro_input_queue, 
@@ -39,7 +39,13 @@ from .stream_manager import live_stream_manager
 import neuro_simulator.shared_state as shared_state
 
 # --- FastAPI 应用和模板设置 ---
-app = FastAPI(title="Neuro-Sama Simulator Backend")
+from .agent.api import router as agent_router
+
+app = FastAPI(title="vedal987 Simulator API", version="1.0.0")
+
+# 注册API路由
+app.include_router(agent_router)
+app.include_router(agent_router)  # Include the agent management API router
 app.add_middleware(
     CORSMiddleware,
     allow_origins=config_manager.settings.server.client_origins + ["http://localhost:8080", "https://dashboard.live.jiahui.cafe"],  # 添加dashboard_web的地址
@@ -142,6 +148,13 @@ async def neuro_response_cycle():
     print("Neuro响应周期: 任务启动。")
     is_first_response = True
     
+    # Dynamically import get_neuro_response to respect agent_type
+    agent_type = config_manager.settings.agent_type
+    if agent_type == "builtin":
+        from .builtin_agent import get_builtin_response as get_neuro_response
+    else:
+        from .letta import get_neuro_response
+
     while True:
         try:
             if is_first_response:
@@ -155,17 +168,42 @@ async def neuro_response_cycle():
             current_queue_snapshot = get_all_neuro_input_chats()
             sample_size = min(config_manager.settings.neuro_behavior.input_chat_sample_size, len(current_queue_snapshot))
             selected_chats = random.sample(current_queue_snapshot, sample_size)
-            ai_full_response_text = await get_neuro_response(selected_chats)
+            
+            # 使用 asyncio.wait_for 添加超时机制，避免长时间阻塞
+            try:
+                ai_full_response_text = await asyncio.wait_for(
+                    get_neuro_response(selected_chats),
+                    timeout=10.0  # 默认10秒超时
+                )
+            except asyncio.TimeoutError:
+                print(f"警告: {agent_type} 响应超时，跳过本轮。")
+                await asyncio.sleep(5)
+                continue
             
             async with shared_state.neuro_last_speech_lock:
-                if ai_full_response_text and ai_full_response_text.strip():
-                    shared_state.neuro_last_speech = ai_full_response_text
+                # Handle both string and dict responses
+                response_text = ""
+                if isinstance(ai_full_response_text, dict):
+                    # Extract the final response from the dict
+                    response_text = ai_full_response_text.get("final_response", "")
+                else:
+                    response_text = ai_full_response_text if ai_full_response_text else ""
+                
+                if response_text and response_text.strip():
+                    shared_state.neuro_last_speech = response_text
                 else:
                     shared_state.neuro_last_speech = "(Neuro-Sama is currently silent...)"
-                    print("警告: 从 Letta 获取的响应为空，跳过本轮。")
+                    print(f"警告: 从 {agent_type} 获取的响应为空，跳过本轮。")
                     continue
             
-            sentences = [s.strip() for s in re.split(r'(?<=[.!?])\s+', ai_full_response_text.replace('\n', ' ').strip()) if s.strip()]
+            # Handle both string and dict responses for sentence splitting
+            response_text = ""
+            if isinstance(ai_full_response_text, dict):
+                response_text = ai_full_response_text.get("final_response", "")
+            else:
+                response_text = ai_full_response_text if ai_full_response_text else ""
+                
+            sentences = [s.strip() for s in re.split(r'(?<=[.!?])\s+', response_text.replace('\n', ' ').strip()) if s.strip()]
             if not sentences:
                 continue
 
@@ -212,7 +250,7 @@ async def neuro_response_cycle():
 async def startup_event():
     """应用启动时执行。"""
     global chatbot_manager
-    configure_logging()
+    configure_server_logging()
     
     # 实例化管理器
     chatbot_manager = ChatbotManager()
@@ -224,6 +262,16 @@ async def startup_event():
     config_manager.register_update_callback(metadata_callback)
     config_manager.register_update_callback(chatbot_manager.handle_config_update)
     
+    # Initialize the appropriate agent
+    from .letta import initialize_agent
+    from .builtin_agent import initialize_builtin_agent
+    
+    agent_type = config_manager.settings.agent_type
+    if agent_type == "builtin":
+        await initialize_builtin_agent()
+    else:
+        await initialize_agent()
+    
     print("FastAPI 应用已启动。请通过外部控制面板控制直播进程。")
 
 @app.on_event("shutdown")
@@ -241,6 +289,13 @@ async def shutdown_event():
 @app.post("/api/stream/start", tags=["Stream Control"], dependencies=[Depends(get_api_token)])
 async def api_start_stream():
     """启动直播"""
+    # If using builtin agent, clear temp memory and context when starting stream
+    agent_type = config_manager.settings.agent_type
+    if agent_type == "builtin":
+        from .builtin_agent import clear_builtin_agent_temp_memory, clear_builtin_agent_context
+        await clear_builtin_agent_temp_memory()
+        await clear_builtin_agent_context()
+    
     if not process_manager.is_running:
         process_manager.start_live_processes()
         return {"status": "success", "message": "直播已启动"}
@@ -264,6 +319,20 @@ async def api_restart_stream():
     process_manager.start_live_processes()
     return {"status": "success", "message": "直播已重启"}
 
+@app.post("/api/agent/reset_memory", tags=["Agent"], dependencies=[Depends(get_api_token)])
+async def api_reset_agent_memory():
+    """重置Agent记忆"""
+    agent_type = config_manager.settings.agent_type
+    
+    if agent_type == "builtin":
+        from .builtin_agent import reset_builtin_agent_memory
+        await reset_builtin_agent_memory()
+        return {"status": "success", "message": "内置Agent记忆已重置"}
+    else:
+        from .letta import reset_neuro_agent_memory
+        await reset_neuro_agent_memory()
+        return {"status": "success", "message": "Letta Agent记忆已重置"}
+
 @app.get("/api/stream/status", tags=["Stream Control"], dependencies=[Depends(get_api_token)])
 async def api_get_stream_status():
     """获取直播状态"""
@@ -272,16 +341,6 @@ async def api_get_stream_status():
         "backend_status": "running" if process_manager.is_running else "stopped"
     }
 
-# -------------------------------------------------------------
-# --- 日志 API 端点 ---
-# -------------------------------------------------------------
-
-@app.get("/api/logs", tags=["Logs"], dependencies=[Depends(get_api_token)])
-async def api_get_logs(lines: int = 50):
-    """获取最近的日志行"""
-    logs_list = list(log_queue)
-    return {"logs": logs_list[-lines:] if len(logs_list) > lines else logs_list}
-
 # -------------------------------------------------------------
 # --- WebSocket 端点 ---
 # -------------------------------------------------------------
@@ -316,23 +375,102 @@ async def websocket_stream_endpoint(websocket: WebSocket):
     finally:
         connection_manager.disconnect(websocket)
 
-@app.websocket("/ws/logs")
-async def websocket_logs_endpoint(websocket: WebSocket):
+@app.websocket("/ws/admin")
+async def websocket_admin_endpoint(websocket: WebSocket):
     await websocket.accept()
     try:
-        for log_entry in list(log_queue):
-            await websocket.send_text(log_entry)
+        # Send initial server logs
+        for log_entry in list(server_log_queue):
+            await websocket.send_json({"type": "server_log", "data": log_entry})
+        
+        # Send initial agent logs
+        for log_entry in list(agent_log_queue):
+            await websocket.send_json({"type": "agent_log", "data": log_entry})
+        
+        # Send initial context
+        # Import the appropriate agent based on config
+        from .config import config_manager
+        agent_type = config_manager.settings.agent_type
+        if agent_type == "builtin":
+            from .builtin_agent import local_agent
+            if local_agent is not None:
+                context_messages = await local_agent.memory_manager.get_recent_context()
+                await websocket.send_json({
+                    "type": "agent_context",
+                    "action": "update",
+                    "messages": context_messages
+                })
+        
+        # Keep track of last context messages to detect changes
+        last_context_messages = []
+        
+        # Start heartbeat task
+        heartbeat_task = asyncio.create_task(send_heartbeat(websocket))
         
         while websocket.client_state == WebSocketState.CONNECTED:
-            if log_queue:
-                log_entry = log_queue.popleft()
-                await websocket.send_text(log_entry)
-            else:
-                await asyncio.sleep(0.1)
+            # Check for new server logs
+            if server_log_queue:
+                log_entry = server_log_queue.popleft()
+                await websocket.send_json({"type": "server_log", "data": log_entry})
+            
+            # Check for new agent logs
+            if agent_log_queue:
+                log_entry = agent_log_queue.popleft()
+                await websocket.send_json({"type": "agent_log", "data": log_entry})
+            
+            # Check for context updates (for builtin agent)
+            if agent_type == "builtin" and local_agent is not None:
+                context_messages = await local_agent.memory_manager.get_recent_context()
+                # Compare with last context to detect changes
+                if context_messages != last_context_messages:
+                    # Send only new messages
+                    if len(context_messages) > len(last_context_messages):
+                        new_messages = context_messages[len(last_context_messages):]
+                        await websocket.send_json({
+                            "type": "agent_context",
+                            "action": "append",
+                            "messages": new_messages
+                        })
+                    else:
+                        # Only send full update if messages were actually removed (e.g., context reset)
+                        # Don't send update if it's just a reordering or modification
+                        if len(context_messages) < len(last_context_messages):
+                            await websocket.send_json({
+                                "type": "agent_context",
+                                "action": "update",
+                                "messages": context_messages
+                            })
+                        else:
+                            # Send as append if same length but different content
+                            await websocket.send_json({
+                                "type": "agent_context",
+                                "action": "append",
+                                "messages": context_messages
+                            })
+                    last_context_messages = context_messages
+            
+            # Small delay to prevent busy waiting
+            await asyncio.sleep(0.1)
     except WebSocketDisconnect:
-        print("日志流客户端已断开连接。")
+        print("管理面板WebSocket客户端已断开连接。")
     finally:
-        print("日志流WebSocket连接关闭。")
+        # Cancel heartbeat task
+        if 'heartbeat_task' in locals():
+            heartbeat_task.cancel()
+        print("管理面板WebSocket连接关闭。")
+
+
+# 心跳任务，定期发送心跳消息以保持连接活跃
+async def send_heartbeat(websocket: WebSocket):
+    while websocket.client_state == WebSocketState.CONNECTED:
+        try:
+            # 发送心跳消息
+            await websocket.send_json({"type": "heartbeat", "timestamp": time.time()})
+            # 每5秒发送一次心跳
+            await asyncio.sleep(5)
+        except Exception as e:
+            print(f"发送心跳消息时出错: {e}")
+            break
 
 
 # -------------------------------------------------------------
@@ -372,6 +510,13 @@ def filter_config_for_frontend(settings):
             'stream_tags': settings.stream_metadata.stream_tags
         }
     
+    # Agent settings (不包含 agent_type)
+    if hasattr(settings, 'agent'):
+        filtered_settings['agent'] = {
+            'agent_provider': settings.agent.agent_provider,
+            'agent_model': settings.agent.agent_model
+        }
+    
     # Neuro behavior settings
     if hasattr(settings, 'neuro_behavior'):
         filtered_settings['neuro_behavior'] = {
@@ -421,6 +566,8 @@ async def update_configs(new_settings: dict):
             'stream_metadata.stream_title',
             'stream_metadata.stream_category',
             'stream_metadata.stream_tags',
+            'agent.agent_provider',  # 添加 agent 配置项（不包含 agent_type）
+            'agent.agent_model',
             'neuro_behavior.input_chat_sample_size',
             'neuro_behavior.post_speech_cooldown_sec',
             'neuro_behavior.initial_greeting',

neuro_simulator/process_manager.py

@@ -27,11 +27,14 @@ class ProcessManager:
         from .main import generate_audience_chat_task, neuro_response_cycle, broadcast_events_task
         from .stream_manager import live_stream_manager
         from .stream_chat import clear_all_queues
-        from .letta import reset_neuro_agent_memory
+        
+        # Initialize Agent and reset memory
+        from .letta import reset_neuro_agent_memory, initialize_agent
+        import asyncio
+        asyncio.create_task(initialize_agent())
         
         # 清理状态和队列，开始新的直播周期
         clear_all_queues()
-        asyncio.create_task(reset_neuro_agent_memory())
         live_stream_manager.reset_stream_state()
 
         # 创建并存储任务

neuro_simulator/stream_manager.py

@@ -84,6 +84,12 @@ class LiveStreamManager:
         print("正在启动新的直播周期...")
         self._stream_start_global_time = time.time()
         
+        # 清除旧的上下文历史
+        from .builtin_agent import local_agent
+        if local_agent is not None:
+            await local_agent.memory_manager.reset_context()
+            print("旧的上下文历史已清除。")
+        
         self._current_phase = self.StreamPhase.INITIALIZING
         print(f"进入阶段: {self.StreamPhase.INITIALIZING}. 广播 'play_welcome_video' 事件。")
         await self.event_queue.put({

{neuro_simulator-0.0.3.dist-info → neuro_simulator-0.1.2.dist-info}/METADATA

@@ -1,13 +1,14 @@
-Metadata-Version: 2.1
-Name: neuro-simulator
-Version: 0.0.3
+Metadata-Version: 2.4
+Name: neuro_simulator
+Version: 0.1.2
 Summary: Neuro Simulator Server
-Home-page: https://github.com/Moha-Master/neuro-simulator
-Author: Moha-Master
-Author-email: hongkongreporter@outlook.com
+Author-email: Moha-Master <hongkongreporter@outlook.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Moha-Master/neuro-simulator
+Project-URL: Repository, https://github.com/Moha-Master/neuro-simulator
+Project-URL: Issues, https://github.com/Moha-Master/neuro-simulator/issues
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
@@ -17,17 +18,22 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: azure-cognitiveservices-speech
 Requires-Dist: fastapi
+Requires-Dist: uvicorn
 Requires-Dist: google-genai
-Requires-Dist: jinja2
+Requires-Dist: azure-cognitiveservices-speech
 Requires-Dist: letta-client
-Requires-Dist: mutagen
 Requires-Dist: openai
+Requires-Dist: pyyaml
 Requires-Dist: pydantic
+Requires-Dist: jinja2
 Requires-Dist: python-multipart
-Requires-Dist: pyyaml
-Requires-Dist: uvicorn
+Requires-Dist: mutagen
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
 
 # Neuro-Simulator 服务端
 
@@ -57,7 +63,7 @@ neuro_simulator/
 ├── shared_state.py      # 全局状态管理
 ├── log_handler.py       # 日志处理模块
 ├── requirements.txt     # Python 依赖列表
-├── setup.py             # Python 包安装配置
+├── pyproject.toml       # Python 包安装配置
 ├── cli.py               # 命令行启动脚本
 ├── config.yaml.example # 自带的备用配置模板
 └── media/               # 自带的备用媒体文件
@@ -75,7 +81,8 @@ working_dir_example/     # 工作目录结构，请将这个目录重命名和
 ## 安装与配置
 
 0. **在运行server前，必须有已经配置完成的Letta Agent。**
-1. 复制一份 `../docs/working_dir_example` 到你想要的位置，作为配置文件目录
+1. 复制一份 `../docs/working_dir_example` 到你想要的位置，作为配置文件目录.
+   - 程序会在未指定 `--dir` 的情况下自动生成一个工作目录，路径为 `~/.config/neuro-simulator/`
 2. 然后进入配置文件目录，复制 `config.yaml.example` 到 `config.yaml`
 3. 编辑 `config.yaml` 文件，填入必要的 API 密钥和配置项：
    - Letta Token 和 Agent ID