neuro-simulator 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

neuro_simulator/core/application.py

@@ -17,10 +17,10 @@ from starlette.websockets import WebSocketState
 # --- Core Imports ---
 from .config import config_manager, AppSettings
 from ..core.agent_factory import create_agent
+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 ---
@@ -58,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 ---
@@ -130,18 +128,42 @@ async def neuro_response_cycle():
 
     while True:
         try:
-            if is_first_response:
-                add_to_neuro_input_queue({"username": "System", "text": config_manager.settings.neuro_behavior.initial_greeting})
-                is_first_response = False
-            elif is_neuro_input_queue_empty():
-                await asyncio.sleep(1)
-                continue
+            selected_chats = []
+            # Superchat logic
+            if app_state.superchat_queue and (time.time() - app_state.last_superchat_time > 10):
+                sc = app_state.superchat_queue.popleft()
+                app_state.last_superchat_time = time.time()
+                await connection_manager.broadcast({"type": "processing_superchat", "data": sc})
+
+                # Agent-specific payload generation for superchats
+                if isinstance(agent, LettaAgent):
+                    selected_chats = [
+                        {"role": "system", "content": "=== RANDOM 10 MSG IN CHATROOM ===\nNO MSG FETCH DUE TO UNPROCESSED HIGHLIGHTED MESSAGE"},
+                        {"role": "system", "content": f"=== HIGHLIGHTED MESSAGE ===\n{sc['username']}: {sc['text']}"}
+                    ]
+                else: # For BuiltinAgent and any other future agents
+                    selected_chats = [{'username': sc['username'], 'text': sc['text']}]
+
+                # Clear the regular input queue to prevent immediate follow-up with normal chats
+                get_all_neuro_input_chats()
+            else:
+                if is_first_response:
+                    add_to_neuro_input_queue({"username": "System", "text": config_manager.settings.neuro_behavior.initial_greeting})
+                    is_first_response = False
+                elif is_neuro_input_queue_empty():
+                    await asyncio.sleep(1)
+                    continue
+                
+                current_queue_snapshot = get_all_neuro_input_chats()
+                if not current_queue_snapshot:
+                    continue
+                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)
             
-            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)
+            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:
@@ -208,7 +230,7 @@ async def startup_event():
     logger.info("FastAPI application has started.")
 
 @app.on_event("shutdown")
-async def shutdown_event():
+def shutdown_event():
     """Actions to perform on application shutdown."""
     if process_manager.is_running:
         process_manager.stop_live_processes()
@@ -232,11 +254,20 @@ async def websocket_stream_endpoint(websocket: WebSocket):
             raw_data = await websocket.receive_text()
             data = json.loads(raw_data)
             if data.get("type") == "user_message":
-                user_message = {"username": data.get("username", "User"), "text": data.get("message", "").strip()}
+                user_message = {"username": data.get("username", "User"), "text": data.get("text", "").strip()}
                 if user_message["text"]:
                     add_to_audience_buffer(user_message)
                     add_to_neuro_input_queue(user_message)
                     await connection_manager.broadcast({"type": "chat_message", **user_message, "is_user_message": True})
+            elif data.get("type") == "superchat":
+                sc_message = {
+                    "username": data.get("username", "User"),
+                    "text": data.get("text", "").strip(),
+                    "sc_type": data.get("sc_type", "bits")
+                }
+                if sc_message["text"]:
+                    app_state.superchat_queue.append(sc_message)
+
     except WebSocketDisconnect:
         pass
     finally:
@@ -245,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})
         
@@ -253,15 +287,174 @@ 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})
         
+        # 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"}
+
+        elif action == "stop_stream":
+            if process_manager.is_running:
+                await process_manager.stop_live_processes()
+            response["payload"] = {"status": "success", "message": "Stream stopped"}
+
+        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"}
+
+        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 == "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):
@@ -275,4 +468,4 @@ def run_server(host: str = None, port: int = None):
         host=server_host,
         port=server_port,
         reload=False
-    )
+    )

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/services/letta.py

@@ -74,8 +74,38 @@ class LettaAgent(BaseAgent):
             logger.warning(f"Failed to reset Letta Agent message history: {e}")
 
     async def process_messages(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
-        if messages:
-            injected_chat_lines = [f"{chat['username']}: {chat['text']}" for chat in messages]
+        # Check if this is a superchat message based on the specific structure
+        # from neuro_response_cycle
+        is_superchat = (
+            len(messages) == 2 and
+            messages[0].get("role") == "system" and
+            messages[1].get("role") == "system" and
+            "HIGHLIGHTED MESSAGE" in messages[1].get("content", "")
+        )
+
+        if is_superchat:
+            try:
+                # Extract username and text from the superchat message
+                # Format is "=== HIGHLIGHTED MESSAGE ===\n{username}: {text}"
+                content_lines = messages[1]["content"].split('\n', 1)
+                user_and_text = content_lines[1]
+                parts = user_and_text.split(':', 1)
+                sc_username = parts[0].strip()
+                sc_text = parts[1].strip()
+                injected_chat_lines = [f"{sc_username}: {sc_text}"]
+                injected_chat_text = (
+                    "Here is a highlighted message from my Twitch chat:\n---\n" +
+                    "\n".join(injected_chat_lines) +
+                    "\n---\nNow, as the streamer Neuro-Sama, please continue the conversation naturally."
+                )
+                logger.info(f"Processing highlighted message for Letta: {injected_chat_lines[0]}")
+            except (IndexError, AttributeError) as e:
+                logger.error(f"Failed to parse superchat for Letta, falling back. Error: {e}")
+                # Fallback to default empty prompt if parsing fails
+                injected_chat_text = "My chat is quiet right now. As Neuro-Sama, what should I say to engage them?"
+
+        elif messages:
+            injected_chat_lines = [f"{chat['username']}: {chat['text']}" for chat in messages if 'username' in chat and 'text' in chat]
             injected_chat_text = (
                 "Here are some recent messages from my Twitch chat:\n---\n" +
                 "\n".join(injected_chat_lines) + 

neuro_simulator/utils/queue.py

@@ -6,6 +6,7 @@ from collections import deque
 from pathlib import Path
 
 from ..core.config import config_manager
+from ..utils.state import app_state
 
 logger = logging.getLogger(__name__.replace("neuro_simulator", "server", 1))
 
@@ -17,7 +18,8 @@ def clear_all_queues():
     """Clears all chat queues."""
     audience_chat_buffer.clear()
     neuro_input_queue.clear()
-    logger.info("All chat queues have been cleared.")
+    app_state.superchat_queue.clear()
+    logger.info("All chat queues (including superchats) have been cleared.")
 
 def add_to_audience_buffer(chat_item: dict):
     """Adds a chat item to the audience buffer."""

neuro_simulator/utils/state.py

@@ -2,6 +2,8 @@
 """Manages the shared state of the application using a singleton class."""
 
 import asyncio
+import time
+from collections import deque
 
 class AppState:
     """A singleton class to hold all shared application state."""
@@ -9,6 +11,8 @@ class AppState:
         self.live_phase_started_event = asyncio.Event()
         self.neuro_last_speech_lock = asyncio.Lock()
         self.neuro_last_speech: str = "Neuro-Sama has just started the stream and hasn't said anything yet."
+        self.superchat_queue = deque()
+        self.last_superchat_time: float = 0.0
 
 # Create a single, globally accessible instance of the AppState.
-app_state = AppState()
+app_state = AppState()

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.2.2.dist-info → neuro_simulator-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuro_simulator
-Version: 0.2.2
+Version: 0.3.1
 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.2.2.dist-info → neuro_simulator-0.3.1.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=TV_3DzP-VgLnHdue0pKYFFQNOV_V7tr4aMuxL802vQg,1783
 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=zN8KOR_nwsYsR1ZcyZU1GlW3-ijFLbjw5lz1g8DYVIU,11578
+neuro_simulator/core/agent_interface.py,sha256=ZXUCtkQUvsBQ5iCb0gTILJaShn5KmSrEgKhd7PK18HE,2794
+neuro_simulator/core/application.py,sha256=lhTn5KR7ek8-kuyD1qWtppImUUz8pOExH9KRNW1SQ3M,21115
 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/letta.py,sha256=iXyzFyPVty3SjYCHOJAF1QqhUFmxTQbqk8lYJOwB5pc,9415
+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/queue.py,sha256=7SSnUnrqxHkqSeYVjp1S5kpr8qlo4IVdU2NsGwFQAVw,1546
-neuro_simulator/utils/state.py,sha256=E1ilecgMTOAhiw_kNvLG0akkhdZKhzKLrA3oB4NNVTA,538
-neuro_simulator/utils/websocket.py,sha256=yOdFvJzbNhcUn5EAuyS55G_R8q-snas5OvkOtS8g19E,2292
-neuro_simulator-0.2.2.dist-info/METADATA,sha256=lBjb1G0VhfbDCQhRWQOxJzlt9Ut07XL6zApn6X6G_jo,8676
-neuro_simulator-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-neuro_simulator-0.2.2.dist-info/entry_points.txt,sha256=qVd5ypnRRgU8Cw7rWfZ7o0OXyS9P9hgY-cRoN_mgz9g,51
-neuro_simulator-0.2.2.dist-info/top_level.txt,sha256=V8awSKpcrFnjJDiJxSfy7jtOrnuE2BgAR9hLmfMDWK8,16
-neuro_simulator-0.2.2.dist-info/RECORD,,
+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=1gtVoH1hafBUfVYmwkVDAbjwETeqyC3sWx706nQzSRo,2085
+neuro_simulator-0.3.1.dist-info/METADATA,sha256=lQv9x0KvOZJAA8NwZ8byIaHYTVnSxuHRPyhUyqLC6vw,8643
+neuro_simulator-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+neuro_simulator-0.3.1.dist-info/entry_points.txt,sha256=qVd5ypnRRgU8Cw7rWfZ7o0OXyS9P9hgY-cRoN_mgz9g,51
+neuro_simulator-0.3.1.dist-info/top_level.txt,sha256=V8awSKpcrFnjJDiJxSfy7jtOrnuE2BgAR9hLmfMDWK8,16
+neuro_simulator-0.3.1.dist-info/RECORD,,