neuro-simulator 0.3.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

neuro_simulator/core/config.py

@@ -1,8 +1,9 @@
 # backend/config.py
-import os
+import shutil
+from pathlib import Path
 import yaml
 from pydantic import BaseModel, Field
-from typing import List, Optional, Dict, Any
+from typing import Dict, Optional, List
 import logging
 import asyncio
 from collections.abc import Mapping
@@ -106,76 +107,77 @@ class ConfigManager:
         self._update_callbacks = []
         self._initialized = True
 
-    def _get_config_file_path(self) -> str:
-        """获取配置文件路径"""
-        import sys
-        import argparse
-        
-        # 解析命令行参数以获取工作目录
-        parser = argparse.ArgumentParser()
-        parser.add_argument('--dir', '-D', type=str, help='Working directory')
-        # 只解析已知参数，避免干扰其他模块的参数解析
-        args, _ = parser.parse_known_args()
-        
-        if args.dir:
-            # 如果指定了工作目录，使用该目录下的配置文件
-            config_path = os.path.join(args.dir, "config.yaml")
-        else:
-            # 默认使用 ~/.config/neuro-simulator 目录
-            config_path = os.path.join(os.path.expanduser("~"), ".config", "neuro-simulator", "config.yaml")
-            
-        return config_path
+    import sys
 
-    def _load_config_from_yaml(self) -> dict:
-        # 获取配置文件路径
-        config_path = self._get_config_file_path()
-        
-        # 检查配置文件是否存在
-        if not os.path.exists(config_path):
-            raise FileNotFoundError(f"Configuration file '{config_path}' not found. "
-                                  "Please create it from config.yaml.example.")
-        
+class ConfigManager:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(ConfigManager, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+        self.settings: Optional[AppSettings] = None
+        self._update_callbacks = []
+        self._initialized = True
+
+    def load_and_validate(self, config_path_str: str, example_path_str: str):
+        """Loads the main config file, handling first-run scenarios, and validates it."""
+        config_path = Path(config_path_str)
+        example_path = Path(example_path_str)
+
+        # Scenario 1: Both config and example are missing in the working directory.
+        if not config_path.exists() and not example_path.exists():
+            try:
+                import pkg_resources
+                package_example_path_str = pkg_resources.resource_filename('neuro_simulator', 'core/config.yaml.example')
+                shutil.copy(package_example_path_str, example_path)
+                logging.info(f"Created '{example_path}' from package resource.")
+                logging.error(f"Configuration file '{config_path.name}' not found. A new '{example_path.name}' has been created. Please configure it and rename it to '{config_path.name}'.")
+                sys.exit(1)
+            except Exception as e:
+                logging.error(f"FATAL: Could not create config from package resources: {e}")
+                sys.exit(1)
+
+        # Scenario 2: Config is missing, but example exists.
+        elif not config_path.exists() and example_path.exists():
+            logging.error(f"Configuration file '{config_path.name}' not found, but '{example_path.name}' exists. Please rename it to '{config_path.name}' after configuration.")
+            sys.exit(1)
+
+        # Scenario 3: Config exists, but example is missing.
+        elif config_path.exists() and not example_path.exists():
+            try:
+                import pkg_resources
+                package_example_path_str = pkg_resources.resource_filename('neuro_simulator', 'core/config.yaml.example')
+                shutil.copy(package_example_path_str, example_path)
+                logging.info(f"Created missing '{example_path.name}' from package resource.")
+            except Exception as e:
+                logging.warning(f"Could not create missing '{example_path.name}': {e}")
+
+        # Proceed with loading the config if it exists.
         try:
             with open(config_path, 'r', encoding='utf-8') as f:
-                content = yaml.safe_load(f)
-                if content is None:
+                yaml_config = yaml.safe_load(f)
+                if yaml_config is None:
                     raise ValueError(f"Configuration file '{config_path}' is empty.")
-                return content
-        except Exception as e:
-            logging.error(f"Error loading or parsing {config_path}: {e}")
-            raise
-
-    def _load_settings(self) -> AppSettings:
-        yaml_config = self._load_config_from_yaml()
-        
-        base_settings = AppSettings.model_validate(yaml_config)
-
-        # 检查关键配置项
-        if base_settings.agent_type == "letta":
-            missing_keys = []
-            if not base_settings.api_keys.letta_token:
-                missing_keys.append("api_keys.letta_token")
-            if not base_settings.api_keys.neuro_agent_id:
-                missing_keys.append("api_keys.neuro_agent_id")
             
-            if missing_keys:
-                raise ValueError(f"Critical config missing in config.yaml for letta agent: {', '.join(missing_keys)}. "
-                               f"Please check your config.yaml file against config.yaml.example.")
+            self.settings = AppSettings.model_validate(yaml_config)
+            logging.info("Main configuration loaded successfully.")
 
-        logging.info("Configuration loaded successfully.")
-        return base_settings
+        except Exception as e:
+            logging.error(f"Error loading or parsing {config_path}: {e}")
+            sys.exit(1) # Exit if the main config is invalid
 
     def save_settings(self):
         """Saves the current configuration to config.yaml while preserving comments and formatting."""
+        from .path_manager import path_manager
+        config_file_path = str(path_manager.working_dir / "config.yaml")
+
         try:
-            # 获取配置文件路径
-            config_file_path = self._get_config_file_path()
-            
-            # 检查配置文件目录是否存在，如果不存在则创建
-            config_dir = os.path.dirname(config_file_path)
-            if config_dir and not os.path.exists(config_dir):
-                os.makedirs(config_dir, exist_ok=True)
-            
             # 1. Read the existing config file as text to preserve comments and formatting
             with open(config_file_path, 'r', encoding='utf-8') as f:
                 config_lines = f.readlines()
@@ -184,7 +186,8 @@ class ConfigManager:
             config_to_save = self.settings.model_dump(mode='json', exclude={'api_keys'})
 
             # 3. Read the existing config on disk to get the api_keys that should be preserved.
-            existing_config = self._load_config_from_yaml()
+            with open(config_file_path, 'r', encoding='utf-8') as f:
+                existing_config = yaml.safe_load(f)
             if 'api_keys' in existing_config:
                 # 4. Add the preserved api_keys block back to the data to be saved.
                 config_to_save['api_keys'] = existing_config['api_keys']

neuro_simulator/core/path_manager.py

@@ -0,0 +1,69 @@
+# neuro_simulator/core/path_manager.py
+"""Manages all file and directory paths for the application's working directory."""
+
+import os
+from pathlib import Path
+
+class PathManager:
+    """A centralized manager for all dynamic paths within the working directory."""
+
+    def __init__(self, working_dir: str):
+        """Initializes the PathManager and defines the directory structure."""
+        self.working_dir = Path(working_dir).resolve()
+
+        # Top-level directories
+        self.agents_dir = self.working_dir / "agents"
+        self.assets_dir = self.working_dir / "assets"
+
+        # Agents subdirectories
+        self.neuro_agent_dir = self.agents_dir / "neuro"
+        self.memory_agent_dir = self.agents_dir / "memory_manager"
+        self.shared_memories_dir = self.agents_dir / "memories"
+        self.user_tools_dir = self.agents_dir / "tools"
+        self.builtin_tools_dir = self.user_tools_dir / "builtin_tools"
+
+        # Agent-specific config files
+        self.neuro_config_path = self.neuro_agent_dir / "config.yaml"
+        self.neuro_tools_path = self.neuro_agent_dir / "tools.json"
+        self.neuro_history_path = self.neuro_agent_dir / "history.jsonl"
+        self.neuro_prompt_path = self.neuro_agent_dir / "neuro_prompt.txt"
+
+        self.memory_agent_config_path = self.memory_agent_dir / "config.yaml"
+        self.memory_agent_tools_path = self.memory_agent_dir / "tools.json"
+        self.memory_agent_history_path = self.memory_agent_dir / "history.jsonl"
+        self.memory_agent_prompt_path = self.memory_agent_dir / "memory_prompt.txt"
+
+        # Shared memory files
+        self.init_memory_path = self.shared_memories_dir / "init_memory.json"
+        self.core_memory_path = self.shared_memories_dir / "core_memory.json"
+        self.temp_memory_path = self.shared_memories_dir / "temp_memory.json"
+
+    def initialize_directories(self):
+        """Creates all necessary directories if they don't exist."""
+        dirs_to_create = [
+            self.agents_dir,
+            self.assets_dir,
+            self.neuro_agent_dir,
+            self.memory_agent_dir,
+            self.shared_memories_dir,
+            self.user_tools_dir,
+            self.builtin_tools_dir
+        ]
+        for dir_path in dirs_to_create:
+            os.makedirs(dir_path, exist_ok=True)
+
+        # Create the warning file in the builtin_tools directory
+        warning_file_path = self.builtin_tools_dir / "!!!NO-CHANGE-WILL-BE-SAVED-AFTER-RESTART!!!"
+        if not warning_file_path.exists():
+            warning_file_path.touch()
+
+# A global instance that can be imported and used by other modules.
+# It will be initialized on application startup.
+path_manager: PathManager = None
+
+def initialize_path_manager(working_dir: str):
+    """Initializes the global path_manager instance."""
+    global path_manager
+    if path_manager is None:
+        path_manager = PathManager(working_dir)
+        path_manager.initialize_directories()

neuro_simulator/services/audience.py

@@ -1,7 +1,5 @@
 # neuro_simulator/services/audience.py
-import asyncio
 import logging
-import random
 
 from google import genai
 from google.genai import types

neuro_simulator/services/audio.py

@@ -3,7 +3,6 @@ import asyncio
 import base64
 import html
 import logging
-from pathlib import Path
 
 import azure.cognitiveservices.speech as speechsdk
 

neuro_simulator/services/builtin.py

@@ -1,27 +1,24 @@
 # neuro_simulator/services/builtin.py
 """Builtin agent module for Neuro Simulator"""
 
-import asyncio
-import re
 import logging
 from typing import List, Dict, Any, Optional
 
 from ..core.agent_interface import BaseAgent
 from ..agent.core import Agent as LocalAgent
-from ..services.stream import live_stream_manager
+from ..utils.websocket import connection_manager
 
 logger = logging.getLogger(__name__.replace("neuro_simulator", "server", 1))
 
 async def initialize_builtin_agent() -> Optional[LocalAgent]:
-    """Initializes the builtin agent instance and returns it."""
+    """Initializes a new builtin agent instance and returns it."""
     try:
-        working_dir = live_stream_manager._working_dir
-        agent_instance = LocalAgent(working_dir=working_dir)
+        agent_instance = LocalAgent()
         await agent_instance.initialize()
-        logger.info("Builtin agent implementation initialized successfully.")
+        logger.info("New builtin agent instance initialized successfully.")
         return agent_instance
     except Exception as e:
-        logger.error(f"Failed to initialize local agent implementation: {e}", exc_info=True)
+        logger.error(f"Failed to initialize local agent instance: {e}", exc_info=True)
         return None
 
 class BuiltinAgentWrapper(BaseAgent):
@@ -50,24 +47,18 @@ 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
@@ -76,9 +67,7 @@ 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
@@ -87,31 +76,27 @@ 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()
+        # This method is now for internal use, the dashboard uses the new API
+        schemas = self.agent_instance.tool_manager.get_tool_schemas_for_agent('neuro_agent')
+        return self.agent_instance._format_tool_schemas_for_prompt(schemas)
 
     async def execute_tool(self, tool_name: str, params: Dict[str, Any]) -> Any:
-        result = await self.agent_instance.execute_tool(tool_name, params)
-        # If the tool was add_temp_memory, broadcast temp_memory_updated event
+        result = await self.agent_instance.tool_manager.execute_tool(tool_name, **params)
         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_chat(limit)
+        return await self.agent_instance.get_neuro_history(limit)

neuro_simulator/services/letta.py

@@ -67,11 +67,29 @@ class LettaAgent(BaseAgent):
             raise ValueError("Letta agent ID (neuro_agent_id) is not configured.")
 
     async def reset_memory(self):
+        """Resets message history and clears the conversation_summary block."""
         try:
+            # Reset message history
             await asyncio.to_thread(self.client.agents.messages.reset, agent_id=self.agent_id)
             logger.info(f"Letta Agent (ID: {self.agent_id}) message history has been reset.")
+
+            # Find and clear the conversation_summary block
+            blocks = await asyncio.to_thread(self.client.agents.blocks.list, agent_id=self.agent_id)
+            summary_block = next((block for block in blocks if block.name == "conversation_summary"), None)
+            
+            if summary_block:
+                await asyncio.to_thread(
+                    self.client.agents.blocks.modify,
+                    agent_id=self.agent_id,
+                    block_id=summary_block.id,
+                    content=""
+                )
+                logger.info(f"Cleared content of 'conversation_summary' block (ID: {summary_block.id}) for Letta Agent.")
+            else:
+                logger.warning("'conversation_summary' block not found for Letta Agent, skipping clearing.")
+
         except Exception as e:
-            logger.warning(f"Failed to reset Letta Agent message history: {e}")
+            logger.warning(f"Failed during Letta Agent memory reset: {e}")
 
     async def process_messages(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
         # Check if this is a superchat message based on the specific structure

neuro_simulator/services/stream.py

@@ -11,6 +11,28 @@ from ..utils.state import app_state
 
 logger = logging.getLogger(__name__.replace("neuro_simulator", "server", 1))
 
+_WORKING_DIR = os.getcwd()
+_WELCOME_VIDEO_PATH_BACKEND = os.path.join(_WORKING_DIR, "assets", "neuro_start.mp4")
+_WELCOME_VIDEO_DURATION_SEC_DEFAULT = 10.0
+
+@staticmethod
+def _get_video_duration(video_path: str) -> float:
+    """Gets the duration of an MP4 video file using mutagen."""
+    if not os.path.exists(video_path):
+        logger.warning(f"Video file '{video_path}' not found. Using default duration.")
+        return _WELCOME_VIDEO_DURATION_SEC_DEFAULT
+    try:
+        video = MP4(video_path)
+        duration = video.info.length
+        logger.info(f"Successfully read video duration for '{video_path}': {duration:.2f}s.")
+        return duration
+    except MP4StreamInfoError:
+        logger.warning(f"Could not parse stream info for '{video_path}'. Using default duration.")
+        return _WELCOME_VIDEO_DURATION_SEC_DEFAULT
+    except Exception as e:
+        logger.error(f"Error getting video duration: {e}. Using default duration.")
+        return _WELCOME_VIDEO_DURATION_SEC_DEFAULT
+
 class LiveStreamManager:
     class NeuroAvatarStage:
         HIDDEN = "hidden"
@@ -25,28 +47,9 @@ class LiveStreamManager:
     
     event_queue: asyncio.Queue = asyncio.Queue()
 
-    _working_dir = os.getcwd()
-    _WELCOME_VIDEO_PATH_BACKEND = os.path.join(_working_dir, "assets", "neuro_start.mp4")
+    _WORKING_DIR = os.getcwd()
+    _WELCOME_VIDEO_PATH_BACKEND = os.path.join(_WORKING_DIR, "assets", "neuro_start.mp4")
     _WELCOME_VIDEO_DURATION_SEC_DEFAULT = 10.0
-    
-    @staticmethod
-    def _get_video_duration(video_path: str) -> float:
-        """Gets the duration of an MP4 video file using mutagen."""
-        if not os.path.exists(video_path):
-            logger.warning(f"Video file '{video_path}' not found. Using default duration.")
-            return LiveStreamManager._WELCOME_VIDEO_DURATION_SEC_DEFAULT
-        try:
-            video = MP4(video_path)
-            duration = video.info.length
-            logger.info(f"Successfully read video duration for '{video_path}': {duration:.2f}s.")
-            return duration
-        except MP4StreamInfoError:
-            logger.warning(f"Could not parse stream info for '{video_path}'. Using default duration.")
-            return LiveStreamManager._WELCOME_VIDEO_DURATION_SEC_DEFAULT
-        except Exception as e:
-            logger.error(f"Error getting video duration: {e}. Using default duration.")
-            return LiveStreamManager._WELCOME_VIDEO_DURATION_SEC_DEFAULT
-
     _WELCOME_VIDEO_DURATION_SEC = _get_video_duration(_WELCOME_VIDEO_PATH_BACKEND)
     AVATAR_INTRO_TOTAL_DURATION_SEC = 3.0
 

neuro_simulator/utils/logging.py

@@ -87,4 +87,13 @@ def configure_server_logging():
         uvicorn_logger.handlers = [server_queue_handler, console_handler]
         uvicorn_logger.propagate = False # Prevent double-logging
 
+    # Configure the neuro_agent logger
+    neuro_agent_logger = logging.getLogger("neuro_agent")
+    neuro_agent_queue_handler = QueueLogHandler(agent_log_queue)
+    neuro_agent_queue_handler.setFormatter(queue_formatter)
+    neuro_agent_logger.addHandler(neuro_agent_queue_handler)
+    neuro_agent_logger.addHandler(console_handler) # Also send agent logs to console
+    neuro_agent_logger.setLevel(logging.INFO)
+    neuro_agent_logger.propagate = False # Prevent double-logging
+
     root_logger.info("Server logging configured with unified formatting for queue and console.")

neuro_simulator/utils/queue.py

@@ -3,16 +3,39 @@
 
 import logging
 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))
 
-# Use settings from the config manager to initialize deque maxlen
-audience_chat_buffer: deque[dict] = deque(maxlen=config_manager.settings.performance.audience_chat_buffer_max_size)
-neuro_input_queue: deque[dict] = deque(maxlen=config_manager.settings.performance.neuro_input_queue_max_size)
+# Deques for chat messages
+audience_chat_buffer: deque[dict] = deque()
+neuro_input_queue: deque[dict] = deque()
+
+def initialize_queues():
+    """
+    Initializes the chat queues with sizes from the loaded configuration.
+    This must be called after the config is loaded.
+    """
+    global audience_chat_buffer, neuro_input_queue
+    
+    settings = config_manager.settings
+    if not settings:
+        logger.error("Queue initialization failed: Config not loaded.")
+        return
+
+    logger.info("Initializing queues with configured sizes.")
+    
+    # Re-initialize the deques with the correct maxlen
+    audience_chat_buffer = deque(
+        audience_chat_buffer, 
+        maxlen=settings.performance.audience_chat_buffer_max_size
+    )
+    neuro_input_queue = deque(
+        neuro_input_queue,
+        maxlen=settings.performance.neuro_input_queue_max_size
+    )
 
 def clear_all_queues():
     """Clears all chat queues."""

neuro_simulator/utils/websocket.py

@@ -1,8 +1,6 @@
 # neuro_simulator/utils/websocket.py
-import asyncio
 import json
 import logging
-from collections import deque
 
 from fastapi import WebSocket
 from starlette.websockets import WebSocketState
@@ -39,7 +37,7 @@ class WebSocketManager:
 
     async def broadcast(self, message: dict):
         for connection in self.active_connections:
-            await connection.send_json(message)
+            await self.send_personal_message(message, connection)
 
     async def broadcast_to_admins(self, message: dict):
         for connection in self.admin_connections:

{neuro_simulator-0.3.3.dist-info → neuro_simulator-0.4.0.dist-info}/METADATA

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

neuro_simulator-0.4.0.dist-info/RECORD

@@ -0,0 +1,46 @@
+neuro_simulator/__init__.py,sha256=-tposzyvg6UckPcfSvtc03UjxBa9oCe_zRvlKf8splk,31
+neuro_simulator/cli.py,sha256=ma7kxzQqPaCbnUrZ516avIAsVk43PEc7-wH7BtfFe4E,5464
+neuro_simulator/agent/__init__.py,sha256=t52CZlyTGWqcGjMs90qvpFpRckY2WSSlO7r_H3K_mSY,32
+neuro_simulator/agent/core.py,sha256=_UkxMV1S33VHjD1JFlKz17GpaDhHQGNA9s9dsRgd3j0,9561
+neuro_simulator/agent/llm.py,sha256=xPBEXpZ19WOt7YkERNaY9rscNI-ePASTjIt-_sZV7UI,4262
+neuro_simulator/agent/memory_prompt.txt,sha256=wdpdnbOYhMKgPJnnGlcSejGdt2uItrXzDgz9_8cKnqw,824
+neuro_simulator/agent/neuro_prompt.txt,sha256=WSN5Fa6AwVnJaSFhz98fQTb2EtQ35U6w2qga_C-s1Go,1438
+neuro_simulator/agent/memory/__init__.py,sha256=YJ7cynQJI6kD7vjyv3rKc-CZqmoYSuGQtRZl_XdGEps,39
+neuro_simulator/agent/memory/manager.py,sha256=tnwxxAlpS0wEd0jfX2MG9hnyAcuhUiZOIP7mz9LCPh8,5388
+neuro_simulator/agent/tools/__init__.py,sha256=1WZy6PADfi6o1avyy1y-ThWBFAPJ_bBqtkobyYpf5ao,38
+neuro_simulator/agent/tools/add_temp_memory.py,sha256=R6K-iVMD6ykd7pS3uI811dZIkuuAf7nPn9c6xCzqiHc,2127
+neuro_simulator/agent/tools/add_to_core_memory_block.py,sha256=dt7y3w-qr379gS79mdata9w3hHG45wxdVIDXPnROO1Y,2306
+neuro_simulator/agent/tools/base.py,sha256=Xj9ABTAtSFazhQf-qCMMWTCQVLsq48MZtKFVuBsYLQg,1799
+neuro_simulator/agent/tools/create_core_memory_block.py,sha256=uM2vF71Ai3NH2-Qbr7u8nRmo4EoRzWYsTurfUH2X6s8,2766
+neuro_simulator/agent/tools/delete_core_memory_block.py,sha256=_t2NZWZaxuWJsm9Uof3Zscvucyz-xJfyC0KrssSXPGI,1379
+neuro_simulator/agent/tools/get_core_memory_block.py,sha256=vFK6lrbOqdxWVpYa7yF96wkXKMcpQAn4E68GCZlu0Ow,1432
+neuro_simulator/agent/tools/get_core_memory_blocks.py,sha256=UbK-GkPgha35n703bCKzdnoIKgXR4U4YxqsSYWimW6c,1059
+neuro_simulator/agent/tools/manager.py,sha256=-GFeGR1wO2GteIXOwWcFgZ-iPTj1syzGfL7coGSWf4I,7124
+neuro_simulator/agent/tools/remove_from_core_memory_block.py,sha256=uiY69y2iIJYp3Zh8EdtP2_G5Zqfs4YKSmTBd9zcIp_c,2372
+neuro_simulator/agent/tools/speak.py,sha256=7vPbfWjllxSz39HmOUbKRPwPx64q2vsYrqDu-JsfZJk,1870
+neuro_simulator/agent/tools/update_core_memory_block.py,sha256=CQgimyPNLmOuK_pDAiAxV9qEf3Tx6u7OKludlIR08BA,2272
+neuro_simulator/api/__init__.py,sha256=5LWyDSayPGdQS8Rv13nmAKLyhPnMVPyTYDdvoMPB4xw,56
+neuro_simulator/api/system.py,sha256=OJT6m6HIYATMCAKrgeBRhficaiUjIDl9f-WyUT-RoBw,1874
+neuro_simulator/core/__init__.py,sha256=-ojq25c8XA0CU25b0OxcGjH4IWFEDHR-HXSRSZIuKe8,57
+neuro_simulator/core/agent_factory.py,sha256=p3IKT6sNzSpUojQjvbZJu0pbmyyb258sGn_YNSJlqwI,1717
+neuro_simulator/core/agent_interface.py,sha256=ZXUCtkQUvsBQ5iCb0gTILJaShn5KmSrEgKhd7PK18HE,2794
+neuro_simulator/core/application.py,sha256=oJUuKW3U8Uadr1IlzZThef8CgNoW1zncW_U94OFOUPQ,25518
+neuro_simulator/core/config.py,sha256=QRbkm0h_FBTtYd-z5RRauSa1B0cp0LkNHVLqGBOBTYY,15324
+neuro_simulator/core/path_manager.py,sha256=hfjI4s8-WXlgwvPWDSLYMQ2d0OaXPOMYWWlP5xe5NLg,2954
+neuro_simulator/services/__init__.py,sha256=s3ZrAHg5TpJakadAAGY1h0wDw_xqN4Je4aJwJyRBmk4,61
+neuro_simulator/services/audience.py,sha256=sAmvkz1ip1MNqaw7t-9abqfnmp0yh8EdG5bS5KYR-Us,4999
+neuro_simulator/services/audio.py,sha256=EElBue80njZY8_CKQhVtZEcGchJUdmS4EDOvJEEu_LY,2909
+neuro_simulator/services/builtin.py,sha256=NrdQhf4BuB8_evxnz8m6wiY9DgLwhY3l7Yp5TnmHGYo,5156
+neuro_simulator/services/letta.py,sha256=OEM4qYeRRPoj8qY645YZwCHmMfg1McLp0eTbSAu3KL0,11976
+neuro_simulator/services/stream.py,sha256=eueAaxhAwX_n0mT1W0W4YOVCe7fH5uPoMdRf2o0wQMI,5937
+neuro_simulator/utils/__init__.py,sha256=xSEFzjT827W81mNyQ_DLtr00TgFlttqfFgpz9pSxFXQ,58
+neuro_simulator/utils/logging.py,sha256=fAM8mW4czr0RLgAUS6oN-YTWKj5daqwc5g7yjyAgaPw,3892
+neuro_simulator/utils/process.py,sha256=9OYWx8fzaJZqmFUcjQX37AnBhl7YWvrLxDWBa30vqwU,3192
+neuro_simulator/utils/queue.py,sha256=bg-mIFF8ycClwmmfcKSPjAXtvjImzTKf6z7xZc2VX20,2196
+neuro_simulator/utils/state.py,sha256=DdBqSAYfjOFtJfB1hEGhYPh32r1ZvFuVlN_-29_-luA,664
+neuro_simulator/utils/websocket.py,sha256=fjC-qipzjgM_e7XImP12DFmLhvxkMOSr2GnUWws7esE,2058
+neuro_simulator-0.4.0.dist-info/METADATA,sha256=n3zf_b6P5veJQ-VPxlqlCsxCfZXTd2-loTHn6XB4N3w,8643
+neuro_simulator-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+neuro_simulator-0.4.0.dist-info/entry_points.txt,sha256=qVd5ypnRRgU8Cw7rWfZ7o0OXyS9P9hgY-cRoN_mgz9g,51
+neuro_simulator-0.4.0.dist-info/top_level.txt,sha256=V8awSKpcrFnjJDiJxSfy7jtOrnuE2BgAR9hLmfMDWK8,16
+neuro_simulator-0.4.0.dist-info/RECORD,,

neuro_simulator/agent/base.py

@@ -1,43 +0,0 @@
-# agent/base.py
-"""Base classes for Neuro Simulator Agent"""
-
-from abc import ABC, abstractmethod
-from typing import List, Dict, Any, Optional
-
-
-class BaseAgent(ABC):
-    """Abstract base class for all agents"""
-    
-    @abstractmethod
-    async def initialize(self):
-        """Initialize the agent"""
-        pass
-    
-    @abstractmethod
-    async def reset_memory(self):
-        """Reset agent memory"""
-        pass
-    
-    @abstractmethod
-    async def get_response(self, chat_messages: List[Dict[str, str]]) -> Dict[str, Any]:
-        """Get response from the agent
-        
-        Args:
-            chat_messages: List of message dictionaries with 'username' and 'text' keys
-            
-        Returns:
-            Dictionary containing processing details including tool executions and final response
-        """
-        pass
-    
-    @abstractmethod
-    async def process_messages(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
-        """Process messages and generate a response
-        
-        Args:
-            messages: List of message dictionaries with 'username' and 'text' keys
-            
-        Returns:
-            Dictionary containing processing details including tool executions and final response
-        """
-        pass

neuro_simulator/agent/factory.py

@@ -1,30 +0,0 @@
-# agent/factory.py
-"""Factory for creating agent instances"""
-
-from .base import BaseAgent
-from ..config import config_manager
-
-
-async def create_agent() -> BaseAgent:
-    """Create an agent instance based on the configuration"""
-    agent_type = config_manager.settings.agent_type
-    
-    if agent_type == "builtin":
-        from ..builtin_agent import local_agent, BuiltinAgentWrapper, initialize_builtin_agent
-        if local_agent is None:
-            # Try to initialize the builtin agent
-            await initialize_builtin_agent()
-            # Re-import local_agent after initialization
-            from ..builtin_agent import local_agent
-            if local_agent is None:
-                raise RuntimeError("Failed to initialize Builtin agent")
-        return BuiltinAgentWrapper(local_agent)
-    elif agent_type == "letta":
-        from ..letta import get_letta_agent, initialize_letta_client
-        # Try to initialize the letta client
-        initialize_letta_client()
-        agent = get_letta_agent()
-        await agent.initialize()
-        return agent
-    else:
-        raise ValueError(f"Unknown agent type: {agent_type}")

neuro_simulator/api/stream.py

@@ -1 +0,0 @@
-# This file is now empty as all stream control API endpoints have been migrated to WebSockets.