neuro-simulator 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

neuro_simulator/core/application.py

@@ -21,8 +21,6 @@ from ..services.letta import LettaAgent
 from ..services.builtin import BuiltinAgentWrapper
 
 # --- API Routers ---
-from ..api.agent import router as agent_router
-from ..api.stream import router as stream_router
 from ..api.system import router as system_router
 
 # --- Services and Utilities ---
@@ -60,8 +58,6 @@ app.add_middleware(
     expose_headers=["X-API-Token"],
 )
 
-app.include_router(agent_router)
-app.include_router(stream_router)
 app.include_router(system_router)
 
 # --- Background Task Definitions ---
@@ -167,7 +163,7 @@ async def neuro_response_cycle():
             if not selected_chats:
                 continue
             
-            response_result = await asyncio.wait_for(agent.process_messages(selected_chats), timeout=20.0)
+            response_result = await asyncio.wait_for(agent.process_and_respond(selected_chats), timeout=20.0)
             
             response_text = response_result.get("final_response", "").strip()
             if not response_text:
@@ -280,7 +276,10 @@ async def websocket_stream_endpoint(websocket: WebSocket):
 @app.websocket("/ws/admin")
 async def websocket_admin_endpoint(websocket: WebSocket):
     await websocket.accept()
+    # Add the new admin client to a dedicated list
+    connection_manager.admin_connections.append(websocket)
     try:
+        # Send initial state
         for log_entry in list(server_log_queue): await websocket.send_json({"type": "server_log", "data": log_entry})
         for log_entry in list(agent_log_queue): await websocket.send_json({"type": "agent_log", "data": log_entry})
         
@@ -288,15 +287,208 @@ async def websocket_admin_endpoint(websocket: WebSocket):
         initial_context = await agent.get_message_history()
         await websocket.send_json({"type": "agent_context", "action": "update", "messages": initial_context})
         
+        # Send initial stream status
+        status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
+        await websocket.send_json({"type": "stream_status", "payload": status})
+        
+        # Main loop for receiving messages from the client and pushing log updates
         while websocket.client_state == WebSocketState.CONNECTED:
+            # Check for incoming messages
+            try:
+                raw_data = await asyncio.wait_for(websocket.receive_text(), timeout=0.01)
+                data = json.loads(raw_data)
+                await handle_admin_ws_message(websocket, data)
+            except asyncio.TimeoutError:
+                pass # No message received, continue to push logs
+
+            # Push log updates
             if server_log_queue: await websocket.send_json({"type": "server_log", "data": server_log_queue.popleft()})
             if agent_log_queue: await websocket.send_json({"type": "agent_log", "data": agent_log_queue.popleft()})
             await asyncio.sleep(0.1)
+            
     except WebSocketDisconnect:
         pass
     finally:
+        connection_manager.admin_connections.remove(websocket)
         logger.info("Admin WebSocket client disconnected.")
 
+async def handle_admin_ws_message(websocket: WebSocket, data: dict):
+    """Handles incoming messages from the admin WebSocket."""
+    action = data.get("action")
+    payload = data.get("payload", {})
+    request_id = data.get("request_id")
+    
+    agent = await create_agent()
+    response = {"type": "response", "request_id": request_id, "payload": {}}
+
+    try:
+        # Core Memory Actions
+        if action == "get_core_memory_blocks":
+            blocks = await agent.get_memory_blocks()
+            response["payload"] = blocks
+        
+        elif action == "create_core_memory_block":
+            block_id = await agent.create_memory_block(**payload)
+            response["payload"] = {"status": "success", "block_id": block_id}
+            # Broadcast the update to all admins
+            updated_blocks = await agent.get_memory_blocks()
+            from ..utils.websocket import connection_manager
+            await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
+
+        elif action == "update_core_memory_block":
+            await agent.update_memory_block(**payload)
+            response["payload"] = {"status": "success"}
+            # Broadcast the update to all admins
+            updated_blocks = await agent.get_memory_blocks()
+            from ..utils.websocket import connection_manager
+            await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
+
+        elif action == "delete_core_memory_block":
+            await agent.delete_memory_block(**payload)
+            response["payload"] = {"status": "success"}
+            # Broadcast the update to all admins
+            updated_blocks = await agent.get_memory_blocks()
+            from ..utils.websocket import connection_manager
+            await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
+
+        # Temp Memory Actions
+        elif action == "get_temp_memory":
+            temp_mem = await agent.get_temp_memory()
+            response["payload"] = temp_mem
+
+        elif action == "add_temp_memory":
+            await agent.add_temp_memory(**payload)
+            response["payload"] = {"status": "success"}
+            updated_temp_mem = await agent.get_temp_memory()
+            from ..utils.websocket import connection_manager
+            await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": updated_temp_mem})
+
+        elif action == "clear_temp_memory":
+            await agent.clear_temp_memory()
+            response["payload"] = {"status": "success"}
+            updated_temp_mem = await agent.get_temp_memory()
+            await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": updated_temp_mem})
+
+        # Init Memory Actions
+        elif action == "get_init_memory":
+            init_mem = await agent.get_init_memory()
+            response["payload"] = init_mem
+
+        elif action == "update_init_memory":
+            await agent.update_init_memory(**payload)
+            response["payload"] = {"status": "success"}
+            updated_init_mem = await agent.get_init_memory()
+            from ..utils.websocket import connection_manager
+            await connection_manager.broadcast_to_admins({"type": "init_memory_updated", "payload": updated_init_mem})
+
+        # Tool Actions
+        elif action == "get_tools":
+            tools = await agent.get_available_tools()
+            response["payload"] = {"tools": tools}
+
+        elif action == "execute_tool":
+            result = await agent.execute_tool(**payload)
+            response["payload"] = {"result": result}
+
+        # Stream Control Actions
+        elif action == "start_stream":
+            if not process_manager.is_running:
+                process_manager.start_live_processes()
+            response["payload"] = {"status": "success", "message": "Stream started"}
+            # Broadcast stream status update
+            from ..utils.websocket import connection_manager
+            status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
+            await connection_manager.broadcast_to_admins({"type": "stream_status", "payload": status})
+
+        elif action == "stop_stream":
+            if process_manager.is_running:
+                await process_manager.stop_live_processes()
+            response["payload"] = {"status": "success", "message": "Stream stopped"}
+            # Broadcast stream status update
+            from ..utils.websocket import connection_manager
+            status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
+            await connection_manager.broadcast_to_admins({"type": "stream_status", "payload": status})
+
+        elif action == "restart_stream":
+            await process_manager.stop_live_processes()
+            await asyncio.sleep(1)
+            process_manager.start_live_processes()
+            response["payload"] = {"status": "success", "message": "Stream restarted"}
+            # Broadcast stream status update
+            from ..utils.websocket import connection_manager
+            status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
+            await connection_manager.broadcast_to_admins({"type": "stream_status", "payload": status})
+
+        elif action == "get_stream_status":
+            status = {"is_running": process_manager.is_running, "backend_status": "running" if process_manager.is_running else "stopped"}
+            response["payload"] = status
+
+        # Config Management Actions
+        elif action == "get_configs":
+            from ..api.system import filter_config_for_frontend
+            configs = filter_config_for_frontend(config_manager.settings)
+            response["payload"] = configs
+
+        elif action == "update_configs":
+            from ..api.system import filter_config_for_frontend
+            await config_manager.update_settings(payload)
+            updated_configs = filter_config_for_frontend(config_manager.settings)
+            response["payload"] = updated_configs
+            await connection_manager.broadcast_to_admins({"type": "config_updated", "payload": updated_configs})
+
+        elif action == "reload_configs":
+            await config_manager.update_settings({})
+            response["payload"] = {"status": "success", "message": "Configuration reloaded"}
+            from ..api.system import filter_config_for_frontend
+            updated_configs = filter_config_for_frontend(config_manager.settings)
+            await connection_manager.broadcast_to_admins({"type": "config_updated", "payload": updated_configs})
+
+        # Other Agent Actions
+        elif action == "get_agent_context":
+            context = await agent.get_message_history()
+            response["payload"] = context
+
+        elif action == "get_last_prompt":
+            # Check if the agent supports prompt generation introspection
+            agent_instance = getattr(agent, 'agent_instance', None) if hasattr(agent, 'agent_instance') else agent
+            if not hasattr(agent_instance, 'memory_manager') or not hasattr(agent_instance.memory_manager, 'get_recent_chat') or not hasattr(agent_instance, '_build_neuro_prompt'):
+                response["payload"] = {"status": "error", "message": "The active agent does not support prompt generation introspection."}
+            else:
+                recent_history = await agent_instance.memory_manager.get_recent_chat(entries=10)
+                messages_for_prompt = []
+                for entry in recent_history:
+                    if entry.get('role') == 'user':
+                        parts = entry.get('content', '').split(':', 1)
+                        if len(parts) == 2:
+                            messages_for_prompt.append({'username': parts[0].strip(), 'text': parts[1].strip()})
+                        else:
+                            messages_for_prompt.append({'username': 'user', 'text': entry.get('content', '')})
+                prompt = await agent_instance._build_neuro_prompt(messages_for_prompt)
+                response["payload"] = {"prompt": prompt}
+
+        elif action == "reset_agent_memory":
+            await agent.reset_memory()
+            response["payload"] = {"status": "success"}
+            # Broadcast updates for all memory types
+            await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": await agent.get_memory_blocks()})
+            await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": await agent.get_temp_memory()})
+            await connection_manager.broadcast_to_admins({"type": "init_memory_updated", "payload": await agent.get_init_memory()})
+            await connection_manager.broadcast_to_admins({"type": "agent_context", "action": "update", "messages": await agent.get_message_history()})
+
+        else:
+            response["payload"] = {"status": "error", "message": f"Unknown action: {action}"}
+
+        # Send the direct response to the requesting client
+        if request_id:
+            await websocket.send_json(response)
+
+    except Exception as e:
+        logger.error(f"Error handling admin WS message (action: {action}): {e}", exc_info=True)
+        if request_id:
+            response["payload"] = {"status": "error", "message": str(e)}
+            await websocket.send_json(response)
+
+
 # --- Server Entrypoint ---
 
 def run_server(host: str = None, port: int = None):

neuro_simulator/services/builtin.py

@@ -37,8 +37,8 @@ class BuiltinAgentWrapper(BaseAgent):
     async def reset_memory(self):
         await self.agent_instance.reset_all_memory()
 
-    async def process_messages(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
-        return await self.agent_instance.process_messages(messages)
+    async def process_and_respond(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
+        return await self.agent_instance.process_and_respond(messages)
 
     # Memory Block Management
     async def get_memory_blocks(self) -> List[Dict[str, Any]]:
@@ -50,13 +50,25 @@ class BuiltinAgentWrapper(BaseAgent):
 
     async def create_memory_block(self, title: str, description: str, content: List[str]) -> Dict[str, str]:
         block_id = await self.agent_instance.memory_manager.create_core_memory_block(title, description, content)
+        # Broadcast core_memory_updated event
+        updated_blocks = await self.get_memory_blocks()
+        from ..utils.websocket import connection_manager
+        await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
         return {"block_id": block_id}
 
     async def update_memory_block(self, block_id: str, title: Optional[str], description: Optional[str], content: Optional[List[str]]):
         await self.agent_instance.memory_manager.update_core_memory_block(block_id, title, description, content)
+        # Broadcast core_memory_updated event
+        updated_blocks = await self.get_memory_blocks()
+        from ..utils.websocket import connection_manager
+        await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
 
     async def delete_memory_block(self, block_id: str):
         await self.agent_instance.memory_manager.delete_core_memory_block(block_id)
+        # Broadcast core_memory_updated event
+        updated_blocks = await self.get_memory_blocks()
+        from ..utils.websocket import connection_manager
+        await connection_manager.broadcast_to_admins({"type": "core_memory_updated", "payload": updated_blocks})
 
     # Init Memory Management
     async def get_init_memory(self) -> Dict[str, Any]:
@@ -64,6 +76,10 @@ class BuiltinAgentWrapper(BaseAgent):
 
     async def update_init_memory(self, memory: Dict[str, Any]):
         await self.agent_instance.memory_manager.update_init_memory(memory)
+        # Broadcast init_memory_updated event
+        updated_init_mem = await self.get_init_memory()
+        from ..utils.websocket import connection_manager
+        await connection_manager.broadcast_to_admins({"type": "init_memory_updated", "payload": updated_init_mem})
 
     # Temp Memory Management
     async def get_temp_memory(self) -> List[Dict[str, Any]]:
@@ -71,17 +87,31 @@ class BuiltinAgentWrapper(BaseAgent):
 
     async def add_temp_memory(self, content: str, role: str):
         await self.agent_instance.memory_manager.add_temp_memory(content, role)
+        # Broadcast temp_memory_updated event
+        updated_temp_mem = await self.get_temp_memory()
+        from ..utils.websocket import connection_manager
+        await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": updated_temp_mem})
 
     async def clear_temp_memory(self):
         await self.agent_instance.memory_manager.reset_temp_memory()
+        # Broadcast temp_memory_updated event
+        updated_temp_mem = await self.get_temp_memory()
+        from ..utils.websocket import connection_manager
+        await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": updated_temp_mem})
 
     # Tool Management
     async def get_available_tools(self) -> str:
         return self.agent_instance.tool_manager.get_tool_descriptions()
 
     async def execute_tool(self, tool_name: str, params: Dict[str, Any]) -> Any:
-        return await self.agent_instance.execute_tool(tool_name, params)
+        result = await self.agent_instance.execute_tool(tool_name, params)
+        # If the tool was add_temp_memory, broadcast temp_memory_updated event
+        if tool_name == "add_temp_memory":
+            updated_temp_mem = await self.get_temp_memory()
+            from ..utils.websocket import connection_manager
+            await connection_manager.broadcast_to_admins({"type": "temp_memory_updated", "payload": updated_temp_mem})
+        return result
 
     # Context/Message History
     async def get_message_history(self, limit: int = 20) -> List[Dict[str, Any]]:
-        return await self.agent_instance.memory_manager.get_recent_context(limit)
+        return await self.agent_instance.memory_manager.get_recent_chat(limit)

neuro_simulator/utils/process.py

@@ -33,6 +33,7 @@ class ProcessManager:
         from ..core.application import generate_audience_chat_task, neuro_response_cycle, broadcast_events_task
         from ..utils.queue import clear_all_queues
         from ..core.agent_factory import create_agent
+        from ..utils.websocket import connection_manager
         
         asyncio.create_task(create_agent())
         
@@ -45,6 +46,9 @@ class ProcessManager:
         self._tasks.append(asyncio.create_task(neuro_response_cycle()))
         
         self._is_running = True
+        # Broadcast stream status update
+        status = {"is_running": self._is_running, "backend_status": "running" if self._is_running else "stopped"}
+        asyncio.create_task(connection_manager.broadcast_to_admins({"type": "stream_status", "payload": status}))
         logger.info(f"Core processes started: {len(self._tasks)} tasks.")
 
     async def stop_live_processes(self):
@@ -66,6 +70,10 @@ class ProcessManager:
         
         live_stream_manager.reset_stream_state()
         
+        # Broadcast stream status update
+        status = {"is_running": self._is_running, "backend_status": "running" if self._is_running else "stopped"}
+        await connection_manager.broadcast_to_admins({"type": "stream_status", "payload": status})
+        
         logger.info("All core tasks have been stopped.")
 
 # Global singleton instance

neuro_simulator/utils/websocket.py

@@ -12,7 +12,8 @@ logger = logging.getLogger(__name__.replace("neuro_simulator", "server", 1))
 class WebSocketManager:
     """Manages all active WebSocket connections and provides broadcasting capabilities."""
     def __init__(self):
-        self.active_connections: deque[WebSocket] = deque()
+        self.active_connections: list[WebSocket] = []
+        self.admin_connections: list[WebSocket] = []
         logger.info("WebSocketManager initialized.")
 
     async def connect(self, websocket: WebSocket):
@@ -37,19 +38,15 @@ class WebSocketManager:
                 self.disconnect(websocket)
 
     async def broadcast(self, message: dict):
-        disconnected_sockets = []
-        for connection in list(self.active_connections):
-            if connection.client_state == WebSocketState.CONNECTED:
-                try:
-                    await connection.send_json(message)
-                except Exception as e:
-                    logger.warning(f"Could not broadcast message to client {connection}, it may have disconnected: {e}")
-                    disconnected_sockets.append(connection)
-            else:
-                disconnected_sockets.append(connection)
-        
-        for disconnected_socket in disconnected_sockets:
-            self.disconnect(disconnected_socket)
+        for connection in self.active_connections:
+            await connection.send_json(message)
+
+    async def broadcast_to_admins(self, message: dict):
+        for connection in self.admin_connections:
+            try:
+                await connection.send_json(message)
+            except Exception as e:
+                logger.error(f"Failed to send message to admin connection: {e}")
 
 # Global singleton instance
 connection_manager = WebSocketManager()

{neuro_simulator-0.3.0.dist-info → neuro_simulator-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuro_simulator
-Version: 0.3.0
+Version: 0.3.2
 Summary: Neuro Simulator Server
 Author-email: Moha-Master <hongkongreporter@outlook.com>
 License-Expression: MIT
@@ -69,7 +69,7 @@ neuro_simulator/
 │   ├── memory/          # 记忆管理模块
 │   │   ├── __init__.py
 │   │   ├── manager.py   # 记忆管理器
-│   │   ├── context.json # 上下文记忆文件
+│   │   ├── chat_history.json # 上下文记忆文件
 │   │   ├── core_memory.json # 核心记忆文件
 │   │   ├── init_memory.json # 初始化记忆文件
 │   │   └── temp_memory.json # 临时记忆文件
@@ -109,7 +109,7 @@ working_dir_example/     # 工作目录结构，请将这个目录重命名和
 ├── config.yaml.example  # 自动生成的配置文件模板，必须手动重命名和填写
 └── agent/               # Agent相关文件夹
     └── memory/          # Agent记忆文件夹
-        ├── context.json     # 上下文记忆文件
+        ├── chat_history.json     # 上下文记忆文件
         ├── core_memory.json # 核心记忆文件
         ├── init_memory.json # 初始化记忆文件
         └── temp_memory.json # 临时记忆文件
@@ -191,7 +191,6 @@ neuro -D /path/to/your/config -H 0.0.0.0 -P 8080
 - `/api/configs/*` - 配置管理接口（获取/更新/重载配置）
   - `api_keys` `server` 等敏感配置项无法从接口获取和修改
 - `/api/logs` - 日志获取接口
-- `/api/tts/synthesize` - TTS 合成接口
 - `/api/system/health` - 健康检查接口
 - `/ws/stream` - 客户端使用的直播接口
 - `/ws/admin` - 日志和内建 Agent的 Context 流接口

{neuro_simulator-0.3.0.dist-info → neuro_simulator-0.3.2.dist-info}/RECORD

@@ -1,37 +1,36 @@
 neuro_simulator/__init__.py,sha256=-tposzyvg6UckPcfSvtc03UjxBa9oCe_zRvlKf8splk,31
-neuro_simulator/cli.py,sha256=p2jSNbMsQ2HYau-EX3ygmTRhECU9dbSg0v53xgYjOZ4,3894
+neuro_simulator/cli.py,sha256=Nc-udO0jdRVZjlbebKBjDVOIUzd6tJr13ApBGeBEg2k,3967
 neuro_simulator/agent/__init__.py,sha256=t52CZlyTGWqcGjMs90qvpFpRckY2WSSlO7r_H3K_mSY,32
 neuro_simulator/agent/base.py,sha256=6v2ZO5UpGCwJEkJ23Oe96Rs510tK4ZOEpZ2DB49IZmM,1262
-neuro_simulator/agent/core.py,sha256=CJv0We7ZjW_EKQB54Xq-y3wDu2a2HmoaOAdYR057HOg,8941
+neuro_simulator/agent/core.py,sha256=2mPVCcNKZDRsyYd6L8RzQYlm8LwzoKoP9FJg0W4qcbc,10702
 neuro_simulator/agent/factory.py,sha256=e0IBnqJQM7OuKtglrf-pWwqwmg98wh7tOq5LxF2rV-w,1146
 neuro_simulator/agent/llm.py,sha256=vLz8hp2h2R0JaNfS1RLGYGkri_YoUdlEdNfFVbxeEuI,4261
 neuro_simulator/agent/memory/__init__.py,sha256=YJ7cynQJI6kD7vjyv3rKc-CZqmoYSuGQtRZl_XdGEps,39
-neuro_simulator/agent/memory/manager.py,sha256=z5ZI1agkuOev5gtuGA_g6MS3atB7ufdPRVNZZ89yg1w,9259
+neuro_simulator/agent/memory/manager.py,sha256=UiUJgjiTV7SHCmb3V5sc4OUa_ksEeXBOyvl-WBQviqs,9266
 neuro_simulator/agent/tools/__init__.py,sha256=1WZy6PADfi6o1avyy1y-ThWBFAPJ_bBqtkobyYpf5ao,38
 neuro_simulator/agent/tools/core.py,sha256=o6Oyis-HFD-g6Z_u3T--tkmr9ylKJvybKqMRSMUwi1Q,5555
 neuro_simulator/api/__init__.py,sha256=5LWyDSayPGdQS8Rv13nmAKLyhPnMVPyTYDdvoMPB4xw,56
-neuro_simulator/api/agent.py,sha256=ABl_JoIxB4wW_J2J52bWndmTXkfGJBS5LZmbGuh7zv8,6343
-neuro_simulator/api/stream.py,sha256=Yg-cwjVI2HTLAt7moWbDQ1ZbbP6QE1ZB8LrW6A3tcQk,2081
-neuro_simulator/api/system.py,sha256=hXznMcThuFhwopYWgpzrRxwtBuFnF_b_vinkOaE5XOs,3712
+neuro_simulator/api/stream.py,sha256=hM66flSUygpE-NH9X-ZOV6SiGipBzN1-wjd_wZRpQm4,94
+neuro_simulator/api/system.py,sha256=W05Q41BYAFrw-MTnJ5YJrBG2S1SmTcByoex77GfUaFQ,1787
 neuro_simulator/core/__init__.py,sha256=-ojq25c8XA0CU25b0OxcGjH4IWFEDHR-HXSRSZIuKe8,57
 neuro_simulator/core/agent_factory.py,sha256=qMFidwT5IrOkyNHwmpO8_fRv20KLbaIBfWF-VTFCLNA,1742
-neuro_simulator/core/agent_interface.py,sha256=r58Opcgs7SWVovYTjMWuxF8AiTy9QfRz276_YGmSei0,2791
-neuro_simulator/core/application.py,sha256=fM9XgYBvx-mNB173rYDezbKdLJRTJ5Mr0nOtxNlSfSc,13365
+neuro_simulator/core/agent_interface.py,sha256=ZXUCtkQUvsBQ5iCb0gTILJaShn5KmSrEgKhd7PK18HE,2794
+neuro_simulator/core/application.py,sha256=zQ6QRUU-dyFW2GDKyBxiTO1BKh-Yt6j169YS-MLpalk,23734
 neuro_simulator/core/config.py,sha256=brA8kiekV_995mpz04JiGj1swIWbZZuWWLNYtbroMyE,14884
 neuro_simulator/services/__init__.py,sha256=s3ZrAHg5TpJakadAAGY1h0wDw_xqN4Je4aJwJyRBmk4,61
 neuro_simulator/services/audience.py,sha256=0phlhsujh_GMXm_UMiyOntY-ZMtoseRa_FroIfc5A6w,5028
 neuro_simulator/services/audio.py,sha256=ZscQA25wVYpm9FUl4Hya7tKH8t0TjR3th9-OEZ0G7xk,2934
-neuro_simulator/services/builtin.py,sha256=7ePxEom5HIK6wGto_H5M8JOnAjyiHqUuE381DEGgzjE,3821
+neuro_simulator/services/builtin.py,sha256=nn3sJFPy09JxQkw35icdyGU9hzLTXXazAJkNpdcz6Zs,5848
 neuro_simulator/services/letta.py,sha256=6jBvOTsLMlRILDv-fvX9fhHMONSYeu-ImJGFcKU00kc,11067
 neuro_simulator/services/stream.py,sha256=dG7RuNI_ICohPkqKZ-zlBppo54BgWm_KYBs-ezzc73E,5907
 neuro_simulator/utils/__init__.py,sha256=xSEFzjT827W81mNyQ_DLtr00TgFlttqfFgpz9pSxFXQ,58
 neuro_simulator/utils/logging.py,sha256=BO-q_cCcoeamsc8eJqq2-L3Z8nhApze_v6LnmD-O8Ww,3411
-neuro_simulator/utils/process.py,sha256=9w2JQH59Wy6L8ADrig2QF88iajdykGPZIYJVJe6Al2Y,2603
+neuro_simulator/utils/process.py,sha256=9OYWx8fzaJZqmFUcjQX37AnBhl7YWvrLxDWBa30vqwU,3192
 neuro_simulator/utils/queue.py,sha256=vSkh-BrgfsGN_gDAx2mfK44ydmMapdVyLsDG-7LIJZQ,1643
 neuro_simulator/utils/state.py,sha256=DdBqSAYfjOFtJfB1hEGhYPh32r1ZvFuVlN_-29_-luA,664
-neuro_simulator/utils/websocket.py,sha256=yOdFvJzbNhcUn5EAuyS55G_R8q-snas5OvkOtS8g19E,2292
-neuro_simulator-0.3.0.dist-info/METADATA,sha256=PELlUyyTi3i1u1_EOLIntPwd7-FAXAoy6uiSs2QA2uE,8676
-neuro_simulator-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-neuro_simulator-0.3.0.dist-info/entry_points.txt,sha256=qVd5ypnRRgU8Cw7rWfZ7o0OXyS9P9hgY-cRoN_mgz9g,51
-neuro_simulator-0.3.0.dist-info/top_level.txt,sha256=V8awSKpcrFnjJDiJxSfy7jtOrnuE2BgAR9hLmfMDWK8,16
-neuro_simulator-0.3.0.dist-info/RECORD,,
+neuro_simulator/utils/websocket.py,sha256=1gtVoH1hafBUfVYmwkVDAbjwETeqyC3sWx706nQzSRo,2085
+neuro_simulator-0.3.2.dist-info/METADATA,sha256=HBAqQoRRJmPcm1IxQwderrq7cTO-UhF-ulzqixLNPh8,8643
+neuro_simulator-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+neuro_simulator-0.3.2.dist-info/entry_points.txt,sha256=qVd5ypnRRgU8Cw7rWfZ7o0OXyS9P9hgY-cRoN_mgz9g,51
+neuro_simulator-0.3.2.dist-info/top_level.txt,sha256=V8awSKpcrFnjJDiJxSfy7jtOrnuE2BgAR9hLmfMDWK8,16
+neuro_simulator-0.3.2.dist-info/RECORD,,

neuro_simulator/api/agent.py

@@ -1,163 +0,0 @@
-# neuro_simulator/api/agent.py
-"""Unified API endpoints for agent management, decoupled from implementation."""
-
-from fastapi import APIRouter, Depends, HTTPException, status, Request
-from typing import Dict, Any, List, Optional
-from pydantic import BaseModel
-
-# Imports for the new structure
-from ..core.config import config_manager
-from ..core.agent_factory import create_agent
-from ..core.agent_interface import BaseAgent
-
-router = APIRouter(prefix="/api/agent", tags=["Agent Management"])
-
-# Security dependency (remains the same)
-async def get_api_token(request: Request):
-    password = config_manager.settings.server.panel_password
-    if not password:
-        return True
-    header_token = request.headers.get("X-API-Token")
-    if header_token and header_token == password:
-        return True
-    raise HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="Invalid API token",
-        headers={"WWW-Authenticate": "Bearer"},
-    )
-
-# Pydantic models (remains the same)
-class MessageItem(BaseModel):
-    username: str
-    text: str
-    role: str = "user"
-
-class ToolExecutionRequest(BaseModel):
-    tool_name: str
-    params: Dict[str, Any]
-
-class MemoryUpdateRequest(BaseModel):
-    title: Optional[str] = None
-    description: Optional[str] = None
-    content: Optional[List[str]] = None
-
-class MemoryCreateRequest(BaseModel):
-    title: str
-    description: str
-    content: List[str]
-
-class InitMemoryUpdateRequest(BaseModel):
-    memory: Dict[str, Any]
-
-class TempMemoryItem(BaseModel):
-    content: str
-    role: str = "system"
-
-# Dependency to get the agent instance, making endpoints cleaner
-async def get_agent() -> BaseAgent:
-    return await create_agent()
-
-# A single dependency for both auth and agent instance
-class AgentDeps:
-    def __init__(self, token: bool = Depends(get_api_token), agent: BaseAgent = Depends(get_agent)):
-        self.agent = agent
-
-# --- Refactored Agent Endpoints ---
-
-@router.get("/messages", response_model=List[Dict[str, Any]])
-async def get_agent_messages(deps: AgentDeps = Depends()):
-    """Get agent's detailed message processing history."""
-    return await deps.agent.get_message_history()
-
-@router.get("/context", response_model=List[Dict[str, Any]])
-async def get_agent_context(deps: AgentDeps = Depends()):
-    """Get agent's recent conversation context (last 20 entries)."""
-    return await deps.agent.get_message_history(limit=20)
-
-@router.delete("/messages")
-async def clear_agent_messages(deps: AgentDeps = Depends()):
-    """Clear agent's message history."""
-    await deps.agent.reset_memory()
-    return {"status": "success", "message": "Agent memory reset successfully"}
-
-@router.post("/messages")
-async def send_message_to_agent(message: MessageItem, deps: AgentDeps = Depends()):
-    """Send a message to the agent."""
-    response = await deps.agent.process_messages([message.dict()])
-    return {"response": response}
-
-@router.get("/memory/init", response_model=Dict[str, Any])
-async def get_init_memory(deps: AgentDeps = Depends()):
-    """Get initialization memory content."""
-    return await deps.agent.get_init_memory()
-
-@router.put("/memory/init")
-async def update_init_memory(request: InitMemoryUpdateRequest, deps: AgentDeps = Depends()):
-    """Update initialization memory content."""
-    await deps.agent.update_init_memory(request.memory)
-    return {"status": "success", "message": "Initialization memory updated"}
-
-@router.get("/memory/temp", response_model=List[Dict[str, Any]])
-async def get_temp_memory(deps: AgentDeps = Depends()):
-    """Get all temporary memory content."""
-    return await deps.agent.get_temp_memory()
-
-@router.post("/memory/temp")
-async def add_temp_memory_item(request: TempMemoryItem, deps: AgentDeps = Depends()):
-    """Add an item to temporary memory."""
-    await deps.agent.add_temp_memory(request.content, request.role)
-    return {"status": "success", "message": "Item added to temporary memory"}
-
-@router.delete("/memory/temp")
-async def clear_temp_memory(deps: AgentDeps = Depends()):
-    """Clear temporary memory."""
-    await deps.agent.clear_temp_memory()
-    return {"status": "success", "message": "Temporary memory cleared"}
-
-@router.get("/memory/blocks", response_model=List[Dict[str, Any]])
-async def get_memory_blocks(deps: AgentDeps = Depends()):
-    """Get all memory blocks."""
-    return await deps.agent.get_memory_blocks()
-
-@router.get("/memory/blocks/{block_id}", response_model=Dict[str, Any])
-async def get_memory_block(block_id: str, deps: AgentDeps = Depends()):
-    """Get a specific memory block."""
-    block = await deps.agent.get_memory_block(block_id)
-    if block is None:
-        raise HTTPException(status_code=404, detail="Memory block not found")
-    return block
-
-@router.post("/memory/blocks", response_model=Dict[str, str])
-async def create_memory_block(request: MemoryCreateRequest, deps: AgentDeps = Depends()):
-    """Create a new memory block."""
-    return await deps.agent.create_memory_block(request.title, request.description, request.content)
-
-@router.put("/memory/blocks/{block_id}")
-async def update_memory_block(block_id: str, request: MemoryUpdateRequest, deps: AgentDeps = Depends()):
-    """Update a memory block."""
-    await deps.agent.update_memory_block(block_id, request.title, request.description, request.content)
-    return {"status": "success"}
-
-@router.delete("/memory/blocks/{block_id}")
-async def delete_memory_block(block_id: str, deps: AgentDeps = Depends()):
-    """Delete a memory block."""
-    await deps.agent.delete_memory_block(block_id)
-    return {"status": "success"}
-
-@router.post("/reset_memory")
-async def reset_agent_memory(deps: AgentDeps = Depends()):
-    """Reset all agent memory types."""
-    await deps.agent.reset_memory()
-    return {"status": "success", "message": "Agent memory reset successfully"}
-
-@router.get("/tools")
-async def get_available_tools(deps: AgentDeps = Depends()):
-    """Get list of available tools."""
-    # Return in the format expected by the frontend
-    return {"tools": await deps.agent.get_available_tools()}
-
-@router.post("/tools/execute")
-async def execute_tool(request: ToolExecutionRequest, deps: AgentDeps = Depends()):
-    """Execute a tool with given parameters."""
-    result = await deps.agent.execute_tool(request.tool_name, request.params)
-    return {"result": result}