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

neuro_simulator/letta.py

@@ -3,60 +3,85 @@ from letta_client import Letta, MessageCreate, TextContent, LlmConfig, Assistant
 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: 重置消息历史记录 (上下文) ---
@@ -88,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]
@@ -128,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:
@@ -163,19 +176,34 @@ async def neuro_response_cycle():
                     timeout=10.0  # 默认10秒超时
                 )
             except asyncio.TimeoutError:
-                print("警告: Letta 响应超时，跳过本轮。")
+                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
 
@@ -222,7 +250,7 @@ async def neuro_response_cycle():
 async def startup_event():
     """应用启动时执行。"""
     global chatbot_manager
-    configure_logging()
+    configure_server_logging()
     
     # 实例化管理器
     chatbot_manager = ChatbotManager()
@@ -234,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")
@@ -251,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": "直播已启动"}
@@ -274,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():
     """获取直播状态"""
@@ -282,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 端点 ---
 # -------------------------------------------------------------
@@ -326,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
 
 
 # -------------------------------------------------------------
@@ -382,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'] = {
@@ -431,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.4.dist-info → neuro_simulator-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuro_simulator
-Version: 0.0.4
+Version: 0.1.2
 Summary: Neuro Simulator Server
 Author-email: Moha-Master <hongkongreporter@outlook.com>
 License-Expression: MIT

neuro_simulator-0.1.2.dist-info/RECORD

@@ -0,0 +1,31 @@
+neuro_simulator/__init__.py,sha256=PpTff-dZfzIweg_Ld0Zt8JNAMTtvLtGn_OC0Ms2E2Q8,276
+neuro_simulator/audio_synthesis.py,sha256=fwS0car42-aheCFVQDgRpUTnqLv4DU9Re66PCa6zTBM,2938
+neuro_simulator/builtin_agent.py,sha256=0TrAmIIjg7aCXiZxgXggyBvBSGR-CsVFUcot71NNfck,2751
+neuro_simulator/chatbot.py,sha256=qQamPO5QTPwV1avNXrzjZpiJlWN3X_6vxSZPSA17jb0,5152
+neuro_simulator/cli.py,sha256=rlwUW1ol8_G06OLf0G-ae0WRXofjoTt3eO9l_Ea8XCY,8183
+neuro_simulator/config.py,sha256=brA8kiekV_995mpz04JiGj1swIWbZZuWWLNYtbroMyE,14884
+neuro_simulator/config.yaml.example,sha256=RbSHEAFD9NEuIvgl5Smpasfz4jiZYQgzTovL3MrhhIs,6549
+neuro_simulator/letta.py,sha256=q7ME_idhW6-koOpFfdNZ1-wwr3DEFIyk1hSFKVci24s,7568
+neuro_simulator/log_handler.py,sha256=w8nQ-91CgiZNI94vJA9Ezgt-x5LRL_AbFZ4-0Mc6ekE,1756
+neuro_simulator/main.py,sha256=d8kgo3Bc0q7pXzw6mmDXHOBaZ93JLs2Ov-cNJVuT_ps,28820
+neuro_simulator/process_manager.py,sha256=cQ7XqHz0cbuJQ_ju0PoOxZzzS04ADQVARyKRHIN1bN8,2578
+neuro_simulator/shared_state.py,sha256=cvYg8vGrkuDmb0e-4J1xvIjXVwspRisuxQaIR9YgsyQ,459
+neuro_simulator/stream_chat.py,sha256=X655rrOW8oQ77qAFK-dQDhHT3bYiE9w44a9Na_ikM2w,997
+neuro_simulator/stream_manager.py,sha256=bwY7Dxo_HLPmQw-1IFvptHBZPMeBbBxdw8_oyZHOSkQ,6966
+neuro_simulator/websocket_manager.py,sha256=a9mMAN7xmgK2w9tVDOOzy4DuWSwdAPatSp6bW9fhE3I,2183
+neuro_simulator/agent/__init__.py,sha256=H6eIGBRG5y1FdjUw3BcwP1nWzmMEpIE1XG2xMV_e5Y0,113
+neuro_simulator/agent/api.py,sha256=Oy4xy32B9dPzBeGyjKtw89tAPjKDKnye9fUaGVsHu-s,33483
+neuro_simulator/agent/core.py,sha256=d0jtRDd1B-UnNcYeEMDJGWMLpI0Lf3iEWzBR7_DqUlw,21447
+neuro_simulator/agent/llm.py,sha256=ohINZpP6ybRWfxK89XMM1yYXehKvRVBuy14ksoqrm8I,4125
+neuro_simulator/agent/memory.py,sha256=b41THZj0LCHlW4GApF02NoW1n1WanySLsNl6JMGpYDQ,5416
+neuro_simulator/agent/tools.py,sha256=hwdJ99soOSOFOqfkBl0oGMYVe4U5rfh1HsGkXd3EUFc,2801
+neuro_simulator/agent/memory/__init__.py,sha256=Be08Az0lWn9d51TLfE2UoluIT9yXVfzHPekIjxJnGOU,78
+neuro_simulator/agent/memory/manager.py,sha256=OGFAnd_bLc1Dv0-5JAXCZtIMUBFyk79bfRdQ8ib8ZWA,16352
+neuro_simulator/agent/tools/__init__.py,sha256=8ztH_OkeXaQDxOaKBb78vKIA8IKkRLxyHLnwGtdk9YU,76
+neuro_simulator/agent/tools/core.py,sha256=YsXbwjF5be_yrh0w5goaSWux53LOkLJ91rikgWPUKDQ,5974
+neuro_simulator/media/neuro_start.mp4,sha256=xCLnNzv4THnzRYwkdV6EiqXc-XtFd867R2ZVLDvNp0Y,8226418
+neuro_simulator-0.1.2.dist-info/METADATA,sha256=-tN71ig_UAfvtywp_q3Rd7D_cJukrjohcrxuq8858B4,6366
+neuro_simulator-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+neuro_simulator-0.1.2.dist-info/entry_points.txt,sha256=qVd5ypnRRgU8Cw7rWfZ7o0OXyS9P9hgY-cRoN_mgz9g,51
+neuro_simulator-0.1.2.dist-info/top_level.txt,sha256=V8awSKpcrFnjJDiJxSfy7jtOrnuE2BgAR9hLmfMDWK8,16
+neuro_simulator-0.1.2.dist-info/RECORD,,

neuro_simulator-0.0.4.dist-info/RECORD

@@ -1,20 +0,0 @@
-neuro_simulator/__init__.py,sha256=JJWUFh_lBowSfGMhmC9zixE70cB7GG1pTbjGY4Kg3mU,29
-neuro_simulator/audio_synthesis.py,sha256=fwS0car42-aheCFVQDgRpUTnqLv4DU9Re66PCa6zTBM,2938
-neuro_simulator/chatbot.py,sha256=qQamPO5QTPwV1avNXrzjZpiJlWN3X_6vxSZPSA17jb0,5152
-neuro_simulator/cli.py,sha256=gf_9Ar_uIodL8O2ZhrXhtXXFJzaQ6QCEzWoQub-JOeI,5978
-neuro_simulator/config.py,sha256=7ek1hKi4mxTRv1IdrkkFgY8Hb_JaPL8a637z71TKHpw,9613
-neuro_simulator/config.yaml.example,sha256=uywVEnoFZGZ4g6qdp616Qoi78F2AF21rSG99gtFiY-s,6003
-neuro_simulator/letta.py,sha256=5lcypQE8bnOXVAELSjoRJ27RlLU2C_Skvy4QB85J3Nk,6623
-neuro_simulator/log_handler.py,sha256=JlCtJ7wJ0pruVGVO5u-kz-F5uaYhlBl4H5xoGUFhT18,1079
-neuro_simulator/main.py,sha256=1otrYFzSLO6ctYYV04tKWMNJFCwEuulfPTlsdHH2Uwk,22444
-neuro_simulator/process_manager.py,sha256=KqW11PRJR5e4RSBytaZdkgbd3wxRtWqlz6D0TA4oR1s,2492
-neuro_simulator/shared_state.py,sha256=cvYg8vGrkuDmb0e-4J1xvIjXVwspRisuxQaIR9YgsyQ,459
-neuro_simulator/stream_chat.py,sha256=X655rrOW8oQ77qAFK-dQDhHT3bYiE9w44a9Na_ikM2w,997
-neuro_simulator/stream_manager.py,sha256=vA88HQGgYguFb3_GUDSY-FpTG0rsjt8J-JFtMoCWWCo,6720
-neuro_simulator/websocket_manager.py,sha256=a9mMAN7xmgK2w9tVDOOzy4DuWSwdAPatSp6bW9fhE3I,2183
-neuro_simulator/media/neuro_start.mp4,sha256=xCLnNzv4THnzRYwkdV6EiqXc-XtFd867R2ZVLDvNp0Y,8226418
-neuro_simulator-0.0.4.dist-info/METADATA,sha256=MOHKocm9fsjdBrtzLGVCWQSr2bNQ6NtEJxk5itbH2LE,6366
-neuro_simulator-0.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-neuro_simulator-0.0.4.dist-info/entry_points.txt,sha256=qVd5ypnRRgU8Cw7rWfZ7o0OXyS9P9hgY-cRoN_mgz9g,51
-neuro_simulator-0.0.4.dist-info/top_level.txt,sha256=V8awSKpcrFnjJDiJxSfy7jtOrnuE2BgAR9hLmfMDWK8,16
-neuro_simulator-0.0.4.dist-info/RECORD,,